Changeset 775

Show
Ignore:
Timestamp:
06/26/07 12:16:32 (1 year ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r773 r775  
     12007-05-25  A.D.F  <adefacc@tin.it> 
     2        * cherokee/server.c: 
     3        - removed multiple calls to cherokee_iocache_cleanup(); 
     4        - space cleanups; 
     5 
     6        * cherokee/win32_misc.c: 
     7        - space / indentation cleanup. 
     8 
    192007-05-21  A.D.F  <adefacc@tin.it> 
    210 

  • cherokee/trunk/cherokee/server.c

    r771 r775  
    9999{ 
    100100        ret_t ret; 
    101  
    102         /* Get memory 
    103          */ 
    104101        CHEROKEE_NEW_STRUCT(n, server); 
    105102         
    …… 
    12831280         */ 
    12841281        if (srv->iocache_clean_next < srv->bogo_now) { 
    1285                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1286                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1287                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1288                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1289                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1290                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    1291                 cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    12921282                cherokee_iocache_clean_up (srv->iocache, IOCACHE_BASIC_SIZE);    
    12931283                srv->iocache_clean_next = srv->bogo_now + IOCACHE_DEFAULT_CLEAN_ELAPSE; 

  • cherokee/trunk/cherokee/win32_misc.c

    r597 r775  
    5858static WSADATA wsa_data; 
    5959 
     60 
    6061/* 
    6162 * Constructor/DllMain 
    …… 
    6465exit_function (void) 
    6566{ 
    66    WSACleanup(); 
    67 } 
    68  
    69 void  
    70 init_win32 (void) 
    71 { 
    72   int re; 
    73  
    74   re = WSAStartup (MAKEWORD(1,1), &wsa_data); 
    75   if (re != 0) { 
    76     PRINT_ERROR ("WSAStartup failed; %s\n", win_strerror(GetLastError())); 
    77     exit (-1); 
    78   } 
    79  
    80   atexit (exit_function); 
    81  
    82   first_sock_num = socket (AF_INET, SOCK_STREAM, 0); 
    83   assert (first_sock_num > 0); 
    84   closesocket (first_sock_num); 
    85 } 
     67        WSACleanup(); 
     68} 
     69 
     70 
     71void init_win32 (void) 
     72{ 
     73        int re; 
     74 
     75        re = WSAStartup (MAKEWORD(1,1), &wsa_data); 
     76        if (re != 0) { 
     77                PRINT_ERROR ("WSAStartup failed; %s\n", win_strerror(GetLastError())); 
     78                exit (-1); 
     79        } 
     80 
     81        atexit (exit_function); 
     82 
     83        first_sock_num = socket (AF_INET, SOCK_STREAM, 0); 
     84        assert (first_sock_num > 0); 
     85        closesocket (first_sock_num); 
     86} 
     87 
    8688 
    8789#if !defined(CHEROKEE_EMBEDDED) 
    8890BOOL APIENTRY DllMain (HANDLE dll_handle, DWORD reason, LPVOID reserved) 
    8991{ 
    90   if (reason == DLL_PROCESS_ATTACH) 
    91         init_win32(); 
    92  
    93   (void) dll_handle; 
    94   (void) reserved; 
    95   return (TRUE); 
     92       if (reason == DLL_PROCESS_ATTACH) 
     93               init_win32(); 
     94 
     95       (void) dll_handle; 
     96       (void) reserved; 
     97       return (TRUE); 
    9698} 
    9799#endif 
    98100 
     101 
    99102int getdtablesize (void) 
    100103{ 
    101   return (wsa_data.iMaxSockets + first_sock_num); 
    102 } 
     104        return (wsa_data.iMaxSockets + first_sock_num); 
     105} 
     106 
    103107 
    104108ret_t set_system_fd_num_limit (uint32_t limit) 
    105109{ 
    106   (void) limit; 
    107   return ret_error; 
    108 } 
     110        (void) limit; 
     111        return ret_error; 
     112} 
     113 
    109114 
    110115#undef random 
    111116int random (void) 
    112117{ 
    113   return rand(); 
    114 } 
     118        return rand(); 
     119} 
     120 
    115121 
    116122#undef getgrnam 
    117123struct group *getgrnam (const char *group) 
    118124{ 
    119   return (NULL); 
    120 } 
     125        return (NULL); 
     126} 
     127 
    121128 
    122129#undef crypt 
    …… 
    124131{ 
    125132#ifdef HAVE_OPENSSL 
    126   return DES_crypt (buf, salt); 
     133       return DES_crypt (buf, salt); 
    127134#else 
    128   (void) buf; 
    129   (void) salt; 
    130   SHOULDNT_HAPPEN; 
    131   return ("No crypt"); 
     135       (void) buf; 
     136       (void) salt; 
     137       SHOULDNT_HAPPEN; 
     138       return ("No crypt"); 
    132139#endif 
    133140} 
     141 
    134142 
    135143#undef localtime_r 
    136144struct tm *localtime_r (const time_t *time, struct tm *tm) 
    137145{ 
    138   struct tm *ret; 
    139  
    140   if (!tm) 
    141      return (NULL); 
    142   ret = localtime (time); 
    143   if (ret) 
    144      *tm = *ret; 
    145   return (ret); 
    146 } 
    147  
    148 /* ncpus.c */ 
     146        struct tm *ret; 
     147 
     148        if (!tm) 
     149                return (NULL); 
     150        ret = localtime (time); 
     151        if (ret) 
     152                *tm = *ret; 
     153        return (ret); 
     154} 
     155 
     156 
     157/* ncpus.c 
     158*/ 
    149159int dcc_ncpus (int *ncpus) 
    150160{ 
    151   SYSTEM_INFO sys_info; 
    152  
    153   memset (&sys_info, 0, sizeof(sys_info)); 
    154   GetSystemInfo (&sys_info); 
    155   return_if_fail (sys_info.dwNumberOfProcessors > 0, ret_error); 
    156   *ncpus = sys_info.dwNumberOfProcessors; 
    157   return (ret_ok); 
    158 } 
     161        SYSTEM_INFO sys_info; 
     162 
     163        memset (&sys_info, 0, sizeof(sys_info)); 
     164        GetSystemInfo (&sys_info); 
     165        return_if_fail (sys_info.dwNumberOfProcessors > 0, ret_error); 
     166        *ncpus = sys_info.dwNumberOfProcessors; 
     167        return (ret_ok); 
     168} 
     169 
    159170 
    160171#if defined(CHEROKEE_EMBEDDED) && 0 
    161172#include "handler_phpcgi.h" 
    162173 
     174 
    163175ret_t cherokee_handler_phpcgi_new (cherokee_handler_t **hdl, void *cnt, cherokee_table_t *properties) 
    164176{ 
    165   SHOULDNT_HAPPEN; 
    166   return ret_error; 
    167 } 
     177        SHOULDNT_HAPPEN; 
     178        return ret_error; 
     179} 
     180 
    168181 
    169182ret_t cherokee_handler_phpcgi_init (cherokee_handler_t *hdl) 
    170183{ 
    171   SHOULDNT_HAPPEN; 
    172   return ret_error; 
     184       SHOULDNT_HAPPEN; 
     185       return ret_error; 
    173186} 
    174187#endif 
    175188 
     189 
    176190/* 
    177191 * This function handles most Winsock errors we're able to produce. 
    …… 
    179193static char *get_winsock_error (int err, char *buf, size_t len) 
    180194{ 
    181   char *p; 
    182  
    183   switch (err) 
    184   { 
    185     case WSAEINTR: 
    186         p = "Call interrupted."; 
    187         break; 
    188     case WSAEBADF: 
    189         p = "Bad file"; 
    190         break; 
    191     case WSAEACCES: 
    192         p = "Bad access"; 
    193         break; 
    194     case WSAEFAULT: 
    195         p = "Bad argument"; 
    196         break; 
    197     case WSAEINVAL: 
    198         p = "Invalid arguments"; 
    199         break; 
    200     case WSAEMFILE: 
    201         p = "Out of file descriptors"; 
    202         break; 
    203     case WSAEWOULDBLOCK: 
    204         p = "Call would block"; 
    205         break; 
    206     case WSAEINPROGRESS: 
    207     case WSAEALREADY: 
    208         p = "Blocking call in progress"; 
    209         break; 
    210     case WSAENOTSOCK: 
    211         p = "Descriptor is not a socket."; 
    212         break; 
    213     case WSAEDESTADDRREQ: 
    214         p = "Need destination address"; 
    215         break; 
    216     case WSAEMSGSIZE: 
    217         p = "Bad message size"; 
    218         break; 
    219     case WSAEPROTOTYPE: 
    220         p = "Bad protocol"; 
    221         break; 
    222     case WSAENOPROTOOPT: 
    223         p = "Protocol option is unsupported"; 
    224         break; 
    225     case WSAEPROTONOSUPPORT: 
    226         p = "Protocol is unsupported"; 
    227         break; 
    228     case WSAESOCKTNOSUPPORT: 
    229         p = "Socket is unsupported"; 
    230         break; 
    231     case WSAEOPNOTSUPP: 
    232         p = "Operation not supported"; 
    233         break; 
    234     case WSAEAFNOSUPPORT: 
    235         p = "Address family not supported"; 
    236         break; 
    237     case WSAEPFNOSUPPORT: 
    238         p = "Protocol family not supported"; 
    239         break; 
    240     case WSAEADDRINUSE: 
    241         p = "Address already in use"; 
    242         break; 
    243     case WSAEADDRNOTAVAIL: 
    244         p = "Address not available"; 
    245         break; 
    246     case WSAENETDOWN: 
    247         p = "Network down"; 
    248         break; 
    249     case WSAENETUNREACH: 
    250         p = "Network unreachable"; 
    251         break; 
    252     case WSAENETRESET: 
    253         p = "Network has been reset"; 
    254         break; 
    255     case WSAECONNABORTED: 
    256         p = "Connection was aborted"; 
    257         break; 
    258     case WSAECONNRESET: 
    259         p = "Connection was reset"; 
    260         break; 
    261     case WSAENOBUFS: 
    262         p = "No buffer space"; 
    263         break; 
    264     case WSAEISCONN: 
    265         p = "Socket is already connected"; 
    266         break; 
    267     case WSAENOTCONN: 
    268         p = "Socket is not connected"; 
    269         break; 
    270     case WSAESHUTDOWN: 
    271         p = "Socket has been shut down"; 
    272         break; 
    273     case WSAETOOMANYREFS: 
    274         p = "Too many references"; 
    275         break; 
    276     case WSAETIMEDOUT: 
    277         p = "Timed out"; 
    278         break; 
    279     case WSAECONNREFUSED: 
    280         p = "Connection refused"; 
    281         break; 
    282     case WSAELOOP: 
    283         p = "Loop??"; 
    284         break; 
    285     case WSAENAMETOOLONG: 
    286         p = "Name too long"; 
    287         break; 
    288     case WSAEHOSTDOWN: 
    289         p = "Host down"; 
    290         break; 
    291     case WSAEHOSTUNREACH: 
    292         p = "Host unreachable"; 
    293         break; 
    294     case WSAENOTEMPTY: 
    295         p = "Not empty"; 
    296         break; 
    297     case WSAEPROCLIM: 
    298         p = "Process limit reached"; 
    299         break; 
    300     case WSAEUSERS: 
    301         p = "Too many users"; 
    302         break; 
    303     case WSAEDQUOT: 
    304         p = "Bad quota"; 
    305         break; 
    306     case WSAESTALE: 
    307         p = "Something is stale"; 
    308         break; 
    309     case WSAEREMOTE: 
    310         p = "Remote error"; 
    311         break; 
    312     case WSAEDISCON: 
    313         p = "Disconnected"; 
    314         break; 
    315  
    316     /* Extended Winsock errors */ 
    317     case WSASYSNOTREADY: 
    318         p = "Winsock library is not ready"; 
    319         break; 
    320     case WSANOTINITIALISED: 
    321         p = "Winsock library not initalised"; 
    322         break; 
    323     case WSAVERNOTSUPPORTED: 
    324         p = "Winsock version not supported."; 
    325         break; 
    326  
    327     /* getXbyY() errors (already handled in herrmsg): 
    328        Authoritative Answer: Host not found */ 
    329     case WSAHOST_NOT_FOUND: 
    330         p = "Host not found"; 
    331         break; 
    332  
    333     /* Non-Authoritative: Host not found, or SERVERFAIL */ 
    334     case WSATRY_AGAIN: 
    335         p = "Host not found, try again"; 
    336         break; 
    337  
    338     /* Non recoverable errors, FORMERR, REFUSED, NOTIMP */ 
    339     case WSANO_RECOVERY: 
    340         p = "Unrecoverable error in call to nameserver"; 
    341         break; 
    342  
    343     /* Valid name, no data record of requested type */ 
    344     case WSANO_DATA: 
    345         p = "No data record of requested type"; 
    346         break; 
    347  
    348     default: 
    349         return (NULL); 
    350   } 
    351   strncpy (buf, p, len); 
    352   buf [len-1] = '\0'; 
    353   return buf; 
    354 } 
     195        char *p; 
     196 
     197        switch (err) { 
     198        case WSAEINTR: 
     199                p = "Call interrupted."; 
     200                break; 
     201        case WSAEBADF: 
     202                p = "Bad file"; 
     203                break; 
     204        case WSAEACCES: 
     205                p = "Bad access"; 
     206                break; 
     207        case WSAEFAULT: 
     208                p = "Bad argument"; 
     209                break; 
     210        case WSAEINVAL: 
     211                p = "Invalid arguments"; 
     212                break; 
     213        case WSAEMFILE: 
     214                p = "Out of file descriptors"; 
     215                break; 
     216        case WSAEWOULDBLOCK: 
     217                p = "Call would block"; 
     218                break; 
     219        case WSAEINPROGRESS: 
     220        case WSAEALREADY: 
     221                p = "Blocking call in progress"; 
     222                break; 
     223        case WSAENOTSOCK: 
     224                p = "Descriptor is not a socket."; 
     225                break; 
     226        case WSAEDESTADDRREQ: 
     227                p = "Need destination address"; 
     228                break; 
     229        case WSAEMSGSIZE: 
     230                p = "Bad message size"; 
     231                break; 
     232        case WSAEPROTOTYPE: 
     233                p = "Bad protocol"; 
     234                break; 
     235        case WSAENOPROTOOPT: 
     236                p = "Protocol option is unsupported"; 
     237                break; 
     238        case WSAEPROTONOSUPPORT: 
     239                p = "Protocol is unsupported"; 
     240                break; 
     241        case WSAESOCKTNOSUPPORT: 
     242                p = "Socket is unsupported"; 
     243                break; 
     244        case WSAEOPNOTSUPP: 
     245                p = "Operation not supported"; 
     246                break; 
     247        case WSAEAFNOSUPPORT: 
     248                p = "Address family not supported"; 
     249                break; 
     250        case WSAEPFNOSUPPORT: 
     251                p = "Protocol family not supported"; 
     252                break; 
     253        case WSAEADDRINUSE: 
     254                p = "Address already in use"; 
     255                break; 
     256        case WSAEADDRNOTAVAIL: 
     257                p = "Address not available"; 
     258                break; 
     259        case WSAENETDOWN: 
     260                p = "Network down"; 
     261                break; 
     262        case WSAENETUNREACH: 
     263                p = "Network unreachable"; 
     264                break; 
     265        case WSAENETRESET: 
     266                p = "Network has been reset"; 
     267                break; 
     268        case WSAECONNABORTED: 
     269                p = "Connection was aborted"; 
     270                break; 
     271        case WSAECONNRESET: 
     272                p = "Connection was reset"; 
     273                break; 
     274        case WSAENOBUFS: 
     275                p = "No buffer space"; 
     276                break; 
     277        case WSAEISCONN: 
     278                p = "Socket is already connected"; 
     279                break; 
     280        case WSAENOTCONN: 
     281                p = "Socket is not connected"; 
     282                break; 
     283        case WSAESHUTDOWN: 
     284                p = "Socket has been shut down"; 
     285                break; 
     286        case WSAETOOMANYREFS: 
     287                p = "Too many references"; 
     288                break; 
     289        case WSAETIMEDOUT: 
     290                p = "Timed out"; 
     291                break; 
     292        case WSAECONNREFUSED: 
     293                p = "Connection refused"; 
     294                break; 
     295        case WSAELOOP: 
     296                p = "Loop??"; 
     297                break; 
     298        case WSAENAMETOOLONG: 
     299                p = "Name too long"; 
     300                break; 
     301        case WSAEHOSTDOWN: 
     302                p = "Host down"; 
     303                break; 
     304        case WSAEHOSTUNREACH: 
     305                p = "Host unreachable"; 
     306                break; 
     307        case WSAENOTEMPTY: 
     308                p = "Not empty"; 
     309                break; 
     310        case WSAEPROCLIM: 
     311                p = "Process limit reached"; 
     312                break; 
     313        case WSAEUSERS: 
     314                p = "Too many users"; 
     315                break; 
     316        case WSAEDQUOT: 
     317                p = "Bad quota"; 
     318                break; 
     319        case WSAESTALE: 
     320                p = "Something is stale"; 
     321                break; 
     322        case WSAEREMOTE: 
     323                p = "Remote error"; 
     324                break; 
     325        case WSAEDISCON: 
     326                p = "Disconnected"; 
     327                break; 
     328 
     329        /* Extended Winsock errors 
     330         */ 
     331        case WSASYSNOTREADY: 
     332                p = "Winsock library is not ready"; 
     333                break; 
     334        case WSANOTINITIALISED: 
     335                p = "Winsock library not initalised"; 
     336                break; 
     337        case WSAVERNOTSUPPORTED: 
     338                p = "Winsock version not supported."; 
     339                break; 
     340 
     341        /* getXbyY() errors (already handled in herrmsg): 
     342         * Authoritative Answer: Host not found 
     343         */ 
     344        case WSAHOST_NOT_FOUND: 
     345                p = "Host not found"; 
     346                break; 
     347 
     348        /* Non-Authoritative: Host not found, or SERVERFAIL 
     349         */ 
     350        case WSATRY_AGAIN: 
     351                p = "Host not found, try again"; 
     352                break; 
     353 
     354        /* Non recoverable errors, FORMERR, REFUSED, NOTIMP 
     355         */ 
     356        case WSANO_RECOVERY: 
     357                p = "Unrecoverable error in call to nameserver"; 
     358                break; 
     359 
     360        /* Valid name, no data record of requested type 
     361         */ 
     362        case WSANO_DATA: 
     363                p = "No data record of requested type"; 
     364                break; 
     365 
     366        default: 
     367                return (NULL); 
     368        } 
     369        strncpy (buf, p, len); 
     370        buf [len-1] = '\0'; 
     371        return buf; 
     372} 
     373 
    355374 
    356375/* 
    …… 
    359378char *win_strerror (int err) 
    360379{ 
    361   static char buf[512];   /* !! not thread-safe */ 
    362   DWORD  lang  = MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT); 
    363   DWORD  flags = FORMAT_MESSAGE_FROM_SYSTEM | 
    364                  FORMAT_MESSAGE_IGNORE_INSERTS | 
    365                  FORMAT_MESSAGE_MAX_WIDTH_MASK; 
    366   char  *p; 
    367  
    368   if (err >= 0 && err < sys_nerr) 
    369   { 
    370     strncpy (buf, strerror(err), sizeof(buf)-1); 
    371     buf [sizeof(buf)-1] = '\0'; 
    372   } 
    373   else 
    374   { 
    375     if (!get_winsock_error (err, buf, sizeof(buf)) && 
    376         !FormatMessage (flags, NULL, err, 
    377                         lang, buf, sizeof(buf)-1, NULL)) 
    378      sprintf (buf, "Unknown error %d (%#x)", err, err); 
    379   } 
    380  
    381   /* strip trailing '\r\n' or '\n'. */ 
    382   if ((p = strrchr(buf,'\n')) != NULL && (p - buf) >= 2) 
    383      *p = '\0'; 
    384   if ((p = strrchr(buf,'\r')) != NULL && (p - buf) >= 1) 
    385      *p = '\0'; 
    386   return (buf); 
     380        static char buf[512];   /* !! not thread-safe */ 
     381        DWORD  lang  = MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT); 
     382        DWORD  flags = FORMAT_MESSAGE_FROM_SYSTEM | 
     383                       FORMAT_MESSAGE_IGNORE_INSERTS | 
     384                       FORMAT_MESSAGE_MAX_WIDTH_MASK; 
     385        char  *p; 
     386 
     387        if (err >= 0 && err < sys_nerr) { 
     388                strncpy (buf, strerror(err), sizeof(buf)-1); 
     389                buf [sizeof(buf)-1] = '\0'; 
     390        } else { 
     391                if (!get_winsock_error (err, buf, sizeof(buf)) && 
     392                    !FormatMessage (flags, NULL, err, lang, 
     393                        buf, sizeof(buf)-1, NULL)) 
     394                        sprintf (buf, "Unknown error %d (%#x)", err, err); 
     395        } 
     396 
     397        /* strip trailing '\r\n' or '\n'. 
     398         */ 
     399        if ((p = strrchr(buf,'\n')) != NULL && (p - buf) >= 2) 
     400                *p = '\0'; 
     401        if ((p = strrchr(buf,'\r')) != NULL && (p - buf) >= 1) 
     402                *p = '\0'; 
     403        return (buf); 
    387404} 
    388405 
    …… 
    403420lookup_mmap (const void *file_ptr, size_t size) 
    404421{ 
    405   struct mmap_list *m; 
    406  
    407   if (!file_ptr || size == 0) 
    408      return (NULL); 
    409  
    410   for (m = mmap_list0; m; m = m->next) 
    411       if (m->file_ptr == file_ptr && m->size == (DWORD)size && m->os_map) 
    412          return (m); 
    413   return (NULL); 
    414 } 
     422        struct mmap_list *m; 
     423 
     424        if (!file_ptr || size == 0) 
     425                return (NULL); 
     426 
     427        for (m = mmap_list0; m; m = m->next) { 
     428                if (m->file_ptr == file_ptr && 
     429                    m->size == (DWORD)size && m->os_map) 
     430                        return (m); 
     431        } 
     432        return (NULL); 
     433} 
     434 
    415435 
    416436static __inline struct mmap_list * 
    417437add_mmap_node (const void *file_ptr, const HANDLE os_map, DWORD size) 
    418438{ 
    419   struct mmap_list *m = calloc (sizeof(*m), 1); 
    420  
    421   if (!m) 
    422      return (NULL); 
    423  
    424   m->os_map   = os_map; 
    425   m->file_ptr = file_ptr; 
    426   m->size     = size; 
    427   m->next     = mmap_list0; 
    428   mmap_list0  = m; 
    429   return (m); 
    430 } 
     439        struct mmap_list *m = calloc (sizeof(*m), 1); 
     440 
     441        if (!m) 
     442                return (NULL); 
     443 
     444        m->os_map   = os_map; 
     445        m->file_ptr = file_ptr; 
     446        m->size     = size; 
     447        m->next     = mmap_list0; 
     448        mmap_list0  = m; 
     449 
     450        return (m); 
     451} 
     452 
    431453 
    432454static __inline struct mmap_list * 
    433455unlink_mmap (struct mmap_list *This) 
    434456{ 
    435   struct mmap_list *m, *prev, *next; 
    436  
    437   for (m = prev = mmap_list0; m; prev = m, m = m->next) 
    438   { 
    439     if (m != This) 
    440        continue; 
    441     if (m == mmap_list0) 
    442          mmap_list0 = m->next; 
    443     else prev->next = m->next; 
    444     next = m->next; 
    445     free (m); 
    446     return (next); 
    447   } 
    448   return (NULL); 
    449 } 
     457        struct mmap_list *m, *prev, *next; 
     458 
     459        for (m = prev = mmap_list0; m; prev = m, m = m->next) { 
     460                if (m != This) 
     461                        continue; 
     462                if (m == mmap_list0) 
     463                        mmap_list0 = m->next; 
     464                else 
     465                        prev->next = m->next; 
     466                next = m->next; 
     467                free (m); 
     468                return (next); 
     469        } 
     470        return (NULL); 
     471} 
     472 
    450473 
    451474/* 
    …… 
    455478void *win_mmap (int fd, size_t size, int prot) 
    456479{ 
    457   struct mmap_list *map = NULL; 
    458   HANDLE os_handle, os_map; 
    459   DWORD  os_prot; 
    460   void  *file_ptr; 
    461  
    462   if (fd < 0 || size == 0 || !(prot & (PROT_READ|PROT_WRITE))) 
    463   { 
    464     SetLastError (errno = EINVAL); 
    465     return (MAP_FAILED); 
    466   } 
    467  
    468   /* todo: 
    469      prot 0                -> PAGE_NOACCESS 
    470      PROT_READ             -> PAGE_READONLY 
    471      PROT_READ|PROT_WRITE  -> PAGE_READWRITE 
    472      PROT_WRITE            -> PAGE_WRITECOPY 
    473   */ 
    474  
    475   os_handle = (HANDLE) _get_osfhandle (fd); 
    476   if (!os_handle) 
    477      return (MAP_FAILED); 
    478  
    479   os_prot = (prot == PROT_READ) ? PAGE_READONLY : PAGE_WRITECOPY; 
    480   os_map = CreateFileMapping (os_handle, NULL, os_prot, 0, 0, NULL); 
    481   if (!os_map) 
    482      return (MAP_FAILED); 
    483  
    484   os_prot = (prot == PROT_READ) ? FILE_MAP_READ : FILE_MAP_WRITE; 
    485   file_ptr = MapViewOfFile (os_map, os_prot, 0, 0, 0); 
    486   if (file_ptr) 
    487   { 
    488     map = add_mmap_node (file_ptr, os_map, size); 
    489     if (!map) 
    490     { 
    491       FlushViewOfFile (file_ptr, size); 
    492       UnmapViewOfFile (file_ptr); 
    493     } 
    494   } 
    495   file_ptr = (map ? (void*)map->file_ptr : NULL); 
    496   if (!file_ptr) 
    497      CloseHandle (os_map); 
     480        struct mmap_list *map = NULL; 
     481        HANDLE os_handle, os_map; 
     482        DWORD  os_prot; 
     483        void  *file_ptr; 
     484 
     485        if (fd < 0 || size == 0 || !(prot & (PROT_READ|PROT_WRITE))) { 
     486                SetLastError (errno = EINVAL); 
     487                return (MAP_FAILED); 
     488        } 
     489 
     490        /* TODO: 
     491         * prot 0                -> PAGE_NOACCESS 
     492         * PROT_READ             -> PAGE_READONLY 
     493         * PROT_READ|PROT_WRITE  -> PAGE_READWRITE 
     494         * PROT_WRITE            -> PAGE_WRITECOPY 
     495         */ 
     496 
     497        os_handle = (HANDLE) _get_osfhandle (fd); 
     498        if (!os_handle) 
     499                return (MAP_FAILED); 
     500 
     501        os_prot = (prot == PROT_READ) ? PAGE_READONLY : PAGE_WRITECOPY; 
     502        os_map = CreateFileMapping (os_handle, NULL, os_prot, 0, 0, NULL); 
     503        if (!os_map) 
     504                return (MAP_FAILED); 
     505 
     506        os_prot = (prot == PROT_READ) ? FILE_MAP_READ : FILE_MAP_WRITE; 
     507        file_ptr = MapViewOfFile (os_map, os_prot, 0, 0, 0); 
     508        if (file_ptr) { 
     509                map = add_mmap_node (file_ptr, os_map, size); 
     510                if (!map) { 
     511                        FlushViewOfFile (file_ptr, size); 
     512                        UnmapViewOfFile (file_ptr); 
     513                } 
     514        } 
     515        file_ptr = (map ? (void*)map->file_ptr : NULL); 
     516        if (!file_ptr) 
     517                CloseHandle (os_map); 
    498518 
    499519#if 0 
    500   TRACE ("mmap", "fd %d, os_map %08lX, file_ptr %08lX, size %u, prot %d\n", 
    501             fd, (DWORD)os_map, (DWORD)file_ptr, size, prot); 
     520       TRACE ("mmap", "fd %d, os_map %08lX, file_ptr %08lX, size %u, prot %d\n", 
     521               fd, (DWORD)os_map, (DWORD)file_ptr, size, prot); 
    502522#endif 
    503523 
    504   return (file_ptr); 
    505 } 
     524        return (file_ptr); 
     525} 
     526 
    506527 
    507528int win_munmap (const void *file_ptr, size_t size) 
    508529{ 
    509   struct mmap_list *m = lookup_mmap (file_ptr, size); 
    510  
    511   if (!m) 
    512   { 
    513     SetLastError (errno = EINVAL); 
    514     return (-1); 
    515   } 
    516   FlushViewOfFile (m->file_ptr, m->size); 
    517   UnmapViewOfFile ((void*)m->file_ptr); 
    518   CloseHandle (m->os_map); 
    519   unlink_mmap (m); 
    520   return (0); 
    521 } 
     530        struct mmap_list *m = lookup_mmap (file_ptr, size); 
     531 
     532        if (!m) { 
     533                SetLastError (errno = EINVAL); 
     534                return (-1); 
     535        } 
     536        FlushViewOfFile (m->file_ptr, m->size); 
     537        UnmapViewOfFile ((void*)m->file_ptr); 
     538        CloseHandle (m->os_map); 
     539        unlink_mmap (m); 
     540 
     541        return (0); 
     542} 
     543 
    522544 
    523545#if !defined(CHEROKEE_EMBEDDED) 
    …… 
    530552void *win_dlopen (const char *dll_name, int flags) 
    531553{ 
    532   void *rc; 
    533  
    534   last_error = 0; 
    535   last_func  = "win_dlopen"; 
    536  
    537   if (dll_name == NULL) 
     554       void *rc; 
     555 
     556       last_error = 0; 
     557       last_func  = "win_dlopen"; 
     558 
     559       if (dll_name == NULL) 
    538560                rc = (void *) GetModuleHandle (NULL); 
    539   else  
     561       else  
    540562                rc = (void *) LoadLibrary (dll_name); 
    541563   
    542   if (rc == NULL) 
     564       if (rc == NULL) 
    543565                last_error = GetLastError(); 
    544566 
    545   TRACE ("dlfcn", "%s, %s\n", dll_name, rc ? "ok" : "fail"); 
    546  
    547   (void) flags; 
    548   return (rc); 
    549 } 
     567        TRACE ("dlfcn", "%s, %s\n", dll_name, rc ? "ok" : "fail"); 
     568 
     569        (void) flags; 
     570 
     571        return (rc); 
     572} 
     573 
    550574 
    551575void *win_dlsym (const void *dll_handle, const char *func_name) 
    552576{ 
    553   HINSTANCE hnd = (HINSTANCE)dll_handle; 
    554   void *rc; 
    555  
    556   if (!hnd) 
    557      hnd = GetModuleHandle (NULL); 
    558  
    559   last_error = 0; 
    560   last_func  = "win_dlsym"; 
    561  
    562   rc = (void*) GetProcAddress (hnd, func_name); 
    563   if (rc == NULL) 
    564        last_error = GetLastError(); 
    565  
    566   TRACE ("dlfcn", "func=%s result=%s error=%d\n", 
    567             func_name, rc ? "ok" : "fail", last_error);   
    568  
    569   return rc; 
    570 } 
     577        HINSTANCE hnd = (HINSTANCE)dll_handle; 
     578        void *rc; 
     579 
     580        if (!hnd) 
     581                hnd = GetModuleHandle (NULL); 
     582 
     583        last_error = 0; 
     584        last_func  = "win_dlsym"; 
     585 
     586        rc = (void*) GetProcAddress (hnd, func_name); 
     587        if (rc == NULL) 
     588                last_error = GetLastError(); 
     589 
     590        TRACE ("dlfcn", "func=%s result=%s error=%d\n", 
     591                func_name, rc ? "ok" : "fail", last_error);   
     592 
     593        return rc; 
     594} 
     595 
    571596 
    572597int win_dlclose (const void *dll_handle) 
    573598{ 
    574   HINSTANCE hnd = (HINSTANCE)dll_handle; 
    575  
    576   TRACE ("dlfcn", "%s\n", hnd ? "ok" : "fail"); 
    577  
    578   last_func = "win_dlclose"; 
    579   if (!hnd) 
    580      return (-1); 
    581  
    582   if (FreeLibrary(hnd)) 
    583        last_error = 0; 
    584   else last_error = GetLastError(); 
    585   return (last_error); 
    586 } 
     599        HINSTANCE hnd = (HINSTANCE)dll_handle; 
     600 
     601        TRACE ("dlfcn", "%s\n", hnd ? "ok" : "fail"); 
     602 
     603        last_func = "win_dlclose"; 
     604        if (!hnd) 
     605                return (-1); 
     606 
     607        if (FreeLibrary(hnd)) 
     608                last_error = 0; 
     609        else 
     610                last_error = GetLastError(); 
     611 
     612        return (last_error); 
     613} 
     614 
    587615 
    588616const char *win_dlerror (void) 
    589617{ 
    590   static char errbuf[1024];  /* !! not thread-safe */ 
    591  
    592   if (!last_error) 
    593      return (NULL); 
    594   snprintf (errbuf, sizeof(errbuf)-1, "%s(): %s", last_func, win_strerror(last_error)); 
    595   return (errbuf); 
     618        static char errbuf[1024];  /* !! not thread-safe */ 
     619 
     620        if (!last_error) 
     621                return (NULL); 
     622 
     623        snprintf (errbuf, sizeof(errbuf)-1, "%s(): %s", 
     624                        last_func, win_strerror(last_error)); 
     625        return (errbuf); 
    596626} 
    597627#endif  /* CHEROKEE_EMBEDDED */ 
    …… 
    631661int inet_pton (int af, const char *src, void *dst) 
    632662{ 
    633   switch (af) 
    634   { 
    635     case AF_INET: 
    636          return inet_pton4(src, dst); 
     663        switch (af) { 
     664        case AF_INET: 
     665                return inet_pton4(src, dst); 
    637666#ifdef HAVE_IPV6 
    638     case AF_INET6: 
    639          return inet_pton6(src, dst); 
     667       case AF_INET6: 
     668               return inet_pton6(src, dst); 
    640669#endif 
    641     default: 
    642          SET_ERRNO (WSAEAFNOSUPPORT); 
    643          return (-1); 
    644   } 
    645 } 
     670        default: 
     671                SET_ERRNO (WSAEAFNOSUPPORT); 
     672                return (-1); 
     673        } 
     674        /* NOTREACHED */ 
     675} 
     676 
    646677 
    647678/* 
    …… 
    653684const char *inet_ntop (int af, const void *src, char *buf, size_t size) 
    654685{ 
    655   switch (af) 
    656   { 
    657     case AF_INET: 
    658          return inet_ntop4 ((const u_char*)src, buf, size); 
     686        switch (af) { 
     687        case AF_INET: 
     688                return inet_ntop4 ((const u_char*)src, buf, size); 
    659689#ifdef HAVE_IPV6 
    660     case AF_INET6: 
    661          return inet_ntop6 ((const u_char*)src, buf, size); 
     690       case AF_INET6: 
     691               return inet_ntop6 ((const u_char*)src, buf, size); 
    662692#endif 
    663     default: 
    664          SET_ERRNO (EAFNOSUPPORT); 
    665          return (NULL); 
    666   } 
    667 } 
     693        default: 
     694                SET_ERRNO (EAFNOSUPPORT); 
     695                return (NULL); 
     696        } 
     697} 
     698 
    668699 
    669700/* 
    …… 
    678709static int inet_pton4 (const char *src, u_char *dst) 
    679710{ 
    680   static const char digits[] = "0123456789"; 
    681   int saw_digit, octets, ch; 
    682   u_char tmp[INADDRSZ], *tp; 
    683  
    684   saw_digit = 0; 
    685   octets = 0; 
    686   *(tp = tmp) = 0; 
    687   while ((ch = *src++) != '\0') 
    688  { 
    689     const char *pch = strchr(digits, ch); 
    690  
    691     if (pch) 
    692     { 
    693       u_int new = *tp * 10 + (pch - digits); 
    694  
    695       if (new > 255) 
    696          return (0); 
    697       *tp = new; 
    698       if (! saw_digit) 
    699       { 
    700         if (++octets > 4) 
    701            return (0); 
    702         saw_digit = 1; 
    703       } 
    704     } 
    705     else if (ch == '.' && saw_digit) 
    706     { 
    707       if (octets == 4) 
    708          return (0); 
    709       *++tp = 0; 
    710       saw_digit = 0; 
    711     } 
    712     else 
    713       return (0); 
    714   } 
    715   if (octets < 4) 
    716      return (0); 
    717  
    718   memcpy (dst, tmp, INADDRSZ); 
    719   return (1); 
     711       static const char digits[] = "0123456789"; 
     712       int saw_digit, octets, ch; 
     713       u_char tmp[INADDRSZ], *tp; 
     714 
     715       saw_digit = 0; 
     716       octets = 0; 
     717       *(tp = tmp) = 0; 
     718 
     719       while ((ch = *src++) != '\0') { 
     720               const char *pch = strchr(digits, ch); 
     721 
     722                if (pch) { 
     723                        u_int new = *tp * 10 + (pch - digits); 
     724 
     725                        if (new > 255) 
     726                                return (0); 
     727 
     728                       *tp = new; 
     729                        if (! saw_digit) { 
     730                                if (++octets > 4) 
     731                                        return (0); 
     732                               saw_digit = 1; 
     733                        } 
     734                } else 
     735                if (ch == '.' && saw_digit) { 
     736                       if (octets == 4) 
     737                                return (0); 
     738                        *++tp = 0; 
     739                       saw_digit = 0; 
     740                } else { 
     741                       return (0); 
     742               } 
     743        } 
     744 
     745        if (octets < 4) 
     746                return (0); 
     747 
     748        memcpy (dst, tmp, INADDRSZ); 
     749 
     750       return (1); 
    720751} 
    721752 
    …… 
    731762static const char *inet_ntop4 (const u_char *src, char *dst, size_t size) 
    732763{ 
    733   const char *addr = inet_ntoa(*(struct in_addr*)src); 
    734  
    735   if (strlen(addr) >= size) 
    736   { 
    737     SET_ERRNO (ENOSPC); 
    738     return (NULL); 
    739   } 
    740<