Changeset a6b4c0df in rtems for cpukit/httpd/misc.c


Ignore:
Timestamp:
09/01/00 10:57:21 (22 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, 5, master
Children:
5f117e8
Parents:
757e1661
Message:

2000-08-30 Joel Sherrill <joel@…>

  • Merged version 2.1 of GoAhead? webserver. This update was submitted by Antti P Miettinen <antti.p.miettinen@…>.
  • NOTES, base64.c, ejIntrn.h, emfdb.c, emfdb.h, md5.h, md5c.c, um.c, um.h: New files.
  • wbase64.c: Removed.
  • Makefile.am, asp.c, balloc.c, default.c, ej.h, ejlex.c, ejparse.c, form.c, h.c, handler.c, mime.c, misc.c, ringq.c, rom.c, security.c, socket.c, sym.c, uemf.c, uemf.h, url.c, value.c, webcomp.c, webmain.c, webpage.c, webrom.c, webs.c, webs.h, websuemf.c, wsIntrn.h: Modified.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/httpd/misc.c

    r757e1661 ra6b4c0df  
    22 * misc.c -- Miscellaneous routines.
    33 *
    4  * Copyright (c) GoAhead Software Inc., 1995-1999. All Rights Reserved.
     4 * Copyright (c) GoAhead Software Inc., 1995-2000. All Rights Reserved.
    55 *
    66 * See the file "license.txt" for usage and redistribution license requirements
     
    1717/********************************* Defines ************************************/
    1818/*
    19  *      Sprintf buffer structure. Make the increment 8 less than 64 so that
     19 *      Sprintf buffer structure. Make the increment 64 so that
    2020 *      a balloc can use a 64 byte block.
    2121 */
    2222
    2323#define STR_REALLOC             0x1                             /* Reallocate the buffer as required */
    24 #define STR_INC                 58                              /* Growth increment */
     24#define STR_INC                 64                              /* Growth increment */
    2525
    2626typedef struct {
     
    6060/*
    6161 *      "basename" returns a pointer to the last component of a pathname
    62  *  LINUX, RTEMS, and LynxOS have their own basename function
    63  */
    64 
    65 #if ! LINUX & ! __rtems__ & ! LYNX
    66 char_t *basename(char_t* name)
     62 *  LINUX and LynxOS have their own basename function
     63 */
     64
     65#if ! LINUX && ! LYNX && ! __rtems__
     66char_t *basename(char_t *name)
    6767{
    6868        char_t  *cp;
     
    8484        }
    8585}
    86 #endif /* ! LINUX && ! __rtems__ && ! LYNX */
     86#endif /* ! LINUX & ! LYNX */
    8787
    8888/******************************************************************************/
     
    9292 */
    9393
    94 char_t *dirname(char_t* buf, char_t* name, int bufsize)
    95 {
    96         char_t* cp;
     94char_t *dirname(char_t *buf, char_t *name, int bufsize)
     95{
     96        char_t *cp;
    9797        int             len;
    9898
     
    131131}
    132132
     133
    133134/******************************************************************************/
    134135/*
    135136 *      sprintf and vsprintf are bad, ok. You can easily clobber memory. Use
    136  *      gsnprintf and gvsnprintf instead! These functions do _not_ support floating
     137 *      fmtAlloc and fmtValloc instead! These functions do _not_ support floating
    137138 *      point, like %e, %f, %g...
    138139 */
    139140
    140 int gsnprintf(char_t **s, int n, char_t *fmt, ...)
     141int fmtAlloc(char_t **s, int n, char_t *fmt, ...)
    141142{
    142143        va_list ap;
     
    148149        *s = NULL;
    149150        va_start(ap, fmt);
    150         result = gvsnprintf(s, n, fmt, ap);
     151        result = dsnprintf(s, n, fmt, ap, 0);
    151152        va_end(ap);
    152153        return result;
     
    155156/******************************************************************************/
    156157/*
     158 *      Support a static buffer version for small buffers only!
     159 */
     160
     161int fmtStatic(char_t *s, int n, char_t *fmt, ...)
     162{
     163        va_list ap;
     164        int             result;
     165
     166        a_assert(s);
     167        a_assert(fmt);
     168        a_assert(n <= 256);
     169
     170        if (n <= 0) {
     171                return -1;
     172        }
     173        va_start(ap, fmt);
     174        result = dsnprintf(&s, n, fmt, ap, 0);
     175        va_end(ap);
     176        return result;
     177}
     178
     179/******************************************************************************/
     180/*
    157181 *      This function appends the formatted string to the supplied string,
    158182 *      reallocing if required.
    159183 */
    160184
    161 int gsprintfRealloc(char_t **s, int n, int msize, char_t *fmt, ...)
     185int fmtRealloc(char_t **s, int n, int msize, char_t *fmt, ...)
    162186{
    163187        va_list ap;
     
    181205 */
    182206
    183 int gvsnprintf(char_t **s, int n, char_t *fmt, va_list arg)
     207int fmtValloc(char_t **s, int n, char_t *fmt, va_list arg)
    184208{
    185209        a_assert(s);
    186210        a_assert(fmt);
    187211
     212        *s = NULL;
    188213        return dsnprintf(s, n, fmt, arg, 0);
    189214}
     
    191216/******************************************************************************/
    192217/*
    193  *      Dynamic sprintf implementation. Supports dynamic buffer allocation also.
     218 *      Dynamic sprintf implementation. Supports dynamic buffer allocation.
    194219 *      This function can be called multiple times to grow an existing allocated
    195220 *      buffer. In this case, msize is set to the size of the previously allocated
     
    253278                                c = *fmt++;
    254279                        } else {
    255                                 for ( ; gisdigit(c); c = *fmt++) {
     280                                for ( ; gisdigit((int)c); c = *fmt++) {
    256281                                        width = width * 10 + (c - '0');
    257282                                }
     
    264289                                        c = *fmt++;
    265290                                } else {
    266                                         for (prec = 0; gisdigit(c); c = *fmt++) {
     291                                        for (prec = 0; gisdigit((int)c); c = *fmt++) {
    267292                                                prec = prec * 10 + (c - '0');
    268293                                        }
     
    403428static void put_char(strbuf_t *buf, char_t c)
    404429{
    405         if (buf->count >= buf->size) {
     430        if (buf->count >= (buf->size - 1)) {
    406431                if (! (buf->flags & STR_REALLOC)) {
    407432                        return;
     
    409434                buf->size += STR_INC;
    410435                if (buf->size > buf->max && buf->size > STR_INC) {
    411                         a_assert(buf->size <= buf->max);
     436/*
     437 *                      Caller should increase the size of the calling buffer
     438 */
    412439                        buf->size -= STR_INC;
    413440                        return;
    414441                }
    415442                if (buf->s == NULL) {
    416                         buf->s = balloc(B_L, buf->size * sizeof(char_t*));
     443                        buf->s = balloc(B_L, buf->size * sizeof(char_t));
    417444                } else {
    418                         buf->s = brealloc(B_L, buf->s, buf->size * sizeof(char_t*));
     445                        buf->s = brealloc(B_L, buf->s, buf->size * sizeof(char_t));
    419446                }
    420447        }
    421448        buf->s[buf->count] = c;
    422         ++buf->count;
     449        if (c != '\0') {
     450                ++buf->count;
     451        }
    423452}
    424453
     
    429458
    430459static void put_string(strbuf_t *buf, char_t *s, int len, int width,
    431         int prec, enum flag f)
     460                int prec, enum flag f)
    432461{
    433462        int             i;
     
    459488
    460489static void put_ulong(strbuf_t *buf, unsigned long int value, int base,
    461         int upper, char_t *prefix, int width, int prec, enum flag f)
     490                int upper, char_t *prefix, int width, int prec, enum flag f)
    462491{
    463492        unsigned long   x, x2;
     
    476505        }
    477506        if (!(f & flag_minus)) {
    478                 for (i = 0; i < width; ++i) {
    479                         put_char(buf, ' ');
     507                if (f & flag_zero) {
     508                        for (i = 0; i < width; ++i) {
     509                                put_char(buf, '0');
     510                        }
     511                } else {
     512                        for (i = 0; i < width; ++i) {
     513                                put_char(buf, ' ');
     514                        }
    480515                }
    481516        }
     
    525560 */
    526561
    527 char *uniToAsc(char *buf, char_t* ustr, int nBytes)
     562char *uniToAsc(char *buf, char_t *ustr, int nBytes)
    528563{
    529564#if UNICODE
     
    538573}
    539574
    540 
    541575/******************************************************************************/
    542576/*
    543577 *      allocate (balloc) a buffer and do ascii to unicode conversion into it.
    544  *      cp points to the ascii string which must be NULL terminated.
    545  *      Return a pointer to the unicode buffer which must be bfree'd later.
    546  *      Return NULL on failure to get buffer.
    547  */
    548 char_t *ballocAscToUni(char * cp)
    549 {
    550         char_t * unip;
     578 *      cp points to the ascii buffer.  alen is the length of the buffer to be
     579 *      converted not including a terminating NULL.  Return a pointer to the
     580 *      unicode buffer which must be bfree'd later.  Return NULL on failure to
     581 *      get buffer.  The buffer returned is NULL terminated.
     582 */
     583
     584char_t *ballocAscToUni(char *cp, int alen)
     585{
     586        char_t *unip;
    551587        int ulen;
    552588
    553         ulen = (strlen(cp) + 1) * sizeof(char_t);
     589        ulen = (alen + 1) * sizeof(char_t);
    554590        if ((unip = balloc(B_L, ulen)) == NULL) {
    555591                return NULL;
    556592        }
    557593        ascToUni(unip, cp, ulen);
     594        unip[alen] = 0;
    558595        return unip;
    559596}
     
    563600 *      allocate (balloc) a buffer and do unicode to ascii conversion into it.
    564601 *      unip points to the unicoded string. ulen is the number of characters
    565  *      in the unicode string including teminating null, if there is one.
    566  *      Return a pointer to the ascii buffer which must be bfree'd later.
    567  *      Return NULL on failure to get buffer.
    568  */
    569 char *ballocUniToAsc(char_t * unip, int ulen)
     602 *      in the unicode string not including a teminating null.  Return a pointer
     603 *      to the ascii buffer which must be bfree'd later.  Return NULL on failure
     604 *      to get buffer.  The buffer returned is NULL terminated.
     605 */
     606
     607char *ballocUniToAsc(char_t *unip, int ulen)
    570608{
    571609        char * cp;
    572610
    573         if ((cp = balloc(B_L, ulen)) == NULL) {
     611        if ((cp = balloc(B_L, ulen+1)) == NULL) {
    574612                return NULL;
    575613        }
    576614        uniToAsc(cp, unip, ulen);
     615        cp[ulen] = '\0';
    577616        return cp;
    578617}
    579618
    580619/******************************************************************************/
    581 
     620/*
     621 *      convert a hex string to an integer. The end of the string or a non-hex
     622 *      character will indicate the end of the hex specification.
     623 */
     624
     625unsigned int hextoi(char_t *hexstring)
     626{
     627        register char_t                 *h;
     628        register unsigned int   c, v;
     629
     630        v = 0;
     631        h = hexstring;
     632        if (*h == '0' && (*(h+1) == 'x' || *(h+1) == 'X')) {
     633                h += 2;
     634        }
     635        while ((c = (unsigned int)*h++) != 0) {
     636                if (c >= '0' && c <= '9') {
     637                        c -= '0';
     638                } else if (c >= 'a' && c <= 'f') {
     639                        c = (c - 'a') + 10;
     640                } else if (c >=  'A' && c <= 'F') {
     641                        c = (c - 'A') + 10;
     642                } else {
     643                        break;
     644                }
     645                v = (v * 0x10) + c;
     646        }
     647        return v;
     648}
     649
     650/******************************************************************************/
     651/*
     652 *      convert a string to an integer. If the string starts with "0x" or "0X"
     653 *      a hexidecimal conversion is done.
     654 */
     655
     656unsigned int gstrtoi(char_t *s)
     657{
     658        if (*s == '0' && (*(s+1) == 'x' || *(s+1) == 'X')) {
     659                s += 2;
     660                return hextoi(s);
     661        }
     662        return gatoi(s);
     663}
     664
     665/******************************************************************************/
     666
Note: See TracChangeset for help on using the changeset viewer.