Changeset 3472 for trunk/src


Ignore:
Timestamp:
May 2, 2000, 3:09:44 PM (25 years ago)
Author:
bird
Message:

Dirty fix to make this compile - QueryPerformanceCounter int odinwrap.h problem.

Location:
trunk/src/wsock32
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/wsock32/asyncapi.cpp

    r3439 r3472  
    1 /* $Id: asyncapi.cpp,v 1.6 2000-04-23 15:55:52 sandervl Exp $ */
     1/* $Id: asyncapi.cpp,v 1.7 2000-05-02 13:09:43 bird Exp $ */
    22
    33/*
    … …  
    3131#include "dbglocal.h"
    3232
     33//kso: dirty fix to make this compile! not permanent!
     34BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *p);
     35#define LowPart u.LowPart
     36
     37
    3338ODINDEBUGCHANNEL(WSOCK32-ASYNC)
    3439
    … …  
    4247 int              size = 0;
    4348 int              fail = NO_ERROR;
    44  
     49
    4550   if(!pThreadParm->fCancelled)
    4651   {
    … …  
    5964                }
    6065                else {
    61                         ret = gethostbyaddr(pThreadParm->u.gethostbyaddr.addr, 
     66                        ret = gethostbyaddr(pThreadParm->u.gethostbyaddr.addr,
    6267                                            pThreadParm->u.gethostbyaddr.len,
    6368                                            pThreadParm->u.gethostbyaddr.type);
    … …  
    152157   if(!pThreadParm->fCancelled) {
    153158        dprintf(("WSAsyncThreadProc %x %x %x %x", pThreadParm->hwnd, pThreadParm->msg, pThreadParm->hAsyncTaskHandle, lParam));
    154         PostMessageA(pThreadParm->hwnd, pThreadParm->msg, 
     159        PostMessageA(pThreadParm->hwnd, pThreadParm->msg,
    155160                     (WPARAM)pThreadParm->hAsyncTaskHandle, lParam);
    156161   }
    157162   pThreadParm->fActive = FALSE;
    158    RemoveFromQueue(pThreadParm); 
    159 }
    160 //******************************************************************************
    161 //******************************************************************************
    162 LHANDLE WSAAsyncRequest(AsyncRequestType requesttype, HWND hwnd, int msg, char *buf, 
     163   RemoveFromQueue(pThreadParm);
     164}
     165//******************************************************************************
     166//******************************************************************************
     167LHANDLE WSAAsyncRequest(AsyncRequestType requesttype, HWND hwnd, int msg, char *buf,
    163168                        int buflen, PVOID param1, PVOID param2, PVOID param3,
    164169                        PVOID param4)
    … …  
    303308   }
    304309   return 0;
    305 }                     
     310}
    306311//******************************************************************************
    307312//******************************************************************************
    … …  
    315320   dprintf(("WSAAsyncGetHostByName %s", name));
    316321
    317    return WSAAsyncRequest(ASYNC_GETHOSTBYNAME, hWnd, wMsg, buf, buflen, 
     322   return WSAAsyncRequest(ASYNC_GETHOSTBYNAME, hWnd, wMsg, buf, buflen,
    318323                          (PVOID)name, 0, 0, 0);
    319324}
    … …  
    331336   dprintf(("WSAAsyncGetHostByAddr %s", addr));
    332337
    333    return WSAAsyncRequest(ASYNC_GETHOSTBYADDR, hWnd, wMsg, buf, buflen, 
     338   return WSAAsyncRequest(ASYNC_GETHOSTBYADDR, hWnd, wMsg, buf, buflen,
    334339                          (PVOID)addr, (PVOID)len, (PVOID)type, 0);
    335340}
    … …  
    345350   dprintf(("WSAAsyncGetProtoByName %s", name));
    346351
    347    return WSAAsyncRequest(ASYNC_GETPROTOBYNAME, hWnd, wMsg, buf, buflen, 
     352   return WSAAsyncRequest(ASYNC_GETPROTOBYNAME, hWnd, wMsg, buf, buflen,
    348353                          (PVOID)name, 0, 0, 0);
    349354}
    … …  
    359364   dprintf(("WSAAsyncGetProtoByNumber %d", number));
    360365
    361    return WSAAsyncRequest(ASYNC_GETPROTOBYNUMBER, hWnd, wMsg, buf, buflen, 
     366   return WSAAsyncRequest(ASYNC_GETPROTOBYNUMBER, hWnd, wMsg, buf, buflen,
    362367                          (PVOID)number, 0, 0, 0);
    363368}
    … …  
    374379   dprintf(("WSAAsyncGetServByName %s", name));
    375380
    376    return WSAAsyncRequest(ASYNC_GETSERVBYNAME, hWnd, wMsg, buf, buflen, 
     381   return WSAAsyncRequest(ASYNC_GETSERVBYNAME, hWnd, wMsg, buf, buflen,
    377382                          (PVOID)name, (PVOID)proto, 0, 0);
    378383}
    … …  
    389394   dprintf(("WSAAsyncGetServByPort %d %s", port, proto));
    390395
    391    return WSAAsyncRequest(ASYNC_GETSERVBYPORT, hWnd, wMsg, buf, buflen, 
     396   return WSAAsyncRequest(ASYNC_GETSERVBYPORT, hWnd, wMsg, buf, buflen,
    392397                          (PVOID)port, (PVOID)proto, 0, 0);
    393398}
    … …  
    401406
    402407   dprintf(("AsyncNotifyEvent %x %x %x %x", pThreadParm->u.asyncselect.s, pThreadParm->hwnd, pThreadParm->msg, event));
    403    PostMessageA(pThreadParm->hwnd, pThreadParm->msg, (WPARAM)pThreadParm->u.asyncselect.s, 
     408   PostMessageA(pThreadParm->hwnd, pThreadParm->msg, (WPARAM)pThreadParm->u.asyncselect.s,
    404409               (LPARAM)event);
    405410}
    … …  
    416421 int              noread, nowrite, noexcept, state, sockoptlen, sockoptval;
    417422 int              tmp, i, lEventsPending, ret, bytesread;
    418  
     423
    419424   while(TRUE)
    420425   {
    … …  
    464469                        selecterr += SOCBASEERR;
    465470                }
    466                 switch(selecterr) 
     471                switch(selecterr)
    467472                {
    468473                case SOCEINTR:
    … …  
    481486                        //but can still send
    482487                        pThreadParm->u.asyncselect.lEventsPending &= ~(FD_READ | FD_ACCEPT);
    483                         goto asyncloopstart; 
     488                        goto asyncloopstart;
    484489
    485490                case SOCEINVAL:
    … …  
    513518                                        AsyncNotifyEvent(pThreadParm, FD_CONNECT, WSAECONNREFUSED);
    514519                                }
    515                         } 
     520                        }
    516521                }
    517522                else
    … …  
    524529        {
    525530                state = ioctl(s, FIONREAD, (CHAR *) &bytesread, sizeof(bytesread));
    526                 if(state == SOCKET_ERROR) 
     531                if(state == SOCKET_ERROR)
    527532                {
    528                         if(lEventsPending & FD_CLOSE) 
     533                        if(lEventsPending & FD_CLOSE)
    529534                        {
    530535                                dprintf(("FD_CLOSE; ioctl; socket error"));
    … …  
    540545                        }
    541546                }
    542                 if(lEventsPending & FD_ACCEPT) 
     547                if(lEventsPending & FD_ACCEPT)
    543548                {
    544549                        sockoptlen = sizeof(sockoptlen);
    … …  
    560565//SvL: This generates FD_CLOSE messages when the connection is just fine
    561566//     (recv executed in another thread when select returns)
    562                 else 
     567                else
    563568                if((lEventsPending & FD_CLOSE) && (state == 0 && bytesread == 0)) {
    564569                        dprintf(("FD_CLOSE; state == 0 && bytesread == 0"));
    … …  
    573578                }
    574579        }
    575         if((pThreadParm->u.asyncselect.lEventsPending & (FD_ACCEPT|FD_CLOSE|FD_CONNECT)) == 
     580        if((pThreadParm->u.asyncselect.lEventsPending & (FD_ACCEPT|FD_CLOSE|FD_CONNECT)) ==
    576581            (lEventsPending & (FD_ACCEPT|FD_CLOSE|FD_CONNECT))) {
    577582                DosSleep(10);
    … …  
    580585   //remove it first, then delete semaphore object
    581586   pThreadParm->fActive = FALSE;
    582    RemoveFromQueue(pThreadParm); 
     587   RemoveFromQueue(pThreadParm);
    583588   delete pThreadParm->u.asyncselect.asyncSem;
    584589   pThreadParm->u.asyncselect.asyncSem = 0;

  • trunk/src/wsock32/unknown.cpp

    r3229 r3472  
    1 /* $Id: unknown.cpp,v 1.7 2000-03-24 19:28:08 sandervl Exp $ */
     1/* $Id: unknown.cpp,v 1.8 2000-05-02 13:09:43 bird Exp $ */
    22
    33/*
    … …  
    1919#define DBG_LOCALLOG    DBG_unknown
    2020#include "dbglocal.h"
     21
     22//kso: dirty fix to make this compile! not permanent!
     23BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *);
     24#define LowPart u.LowPart
    2125
    2226ODINDEBUGCHANNEL(WSOCK32-UNKNOWN)

  • trunk/src/wsock32/wsa.cpp

    r3282 r3472  
    1 /* $Id: wsa.cpp,v 1.5 2000-03-30 20:52:55 sandervl Exp $ */
     1/* $Id: wsa.cpp,v 1.6 2000-05-02 13:09:43 bird Exp $ */
    22
    33/*
    … …  
    3232ODINDEBUGCHANNEL(WSOCK32-WSA)
    3333
     34//kso: dirty fix to make this compile! not permanent!
     35BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *p);
     36#define LowPart u.LowPart
     37
     38
    3439#ifndef winsockcleanupsockets
    3540// Exported by SO32DLL.  Used to close all open sockets.
    … …  
    5964    if (!lpWSAData) return WSAEINVAL;
    6065
    61     if(fWSAInitialized == FALSE) 
     66    if(fWSAInitialized == FALSE)
    6267    {
    6368        WINSOCK_CreateIData();
    … …  
    142147//******************************************************************************
    143148//******************************************************************************
    144 void WSASetBlocking(BOOL fBlock, HANDLE tid) 
     149void WSASetBlocking(BOOL fBlock, HANDLE tid)
    145150{
    146151    LPWSINFO pwsi = WINSOCK_GetIData(tid);
    … …  
    161166{
    162167  int i = set->fd_count;
    163    
     168
    164169  while (i--)
    165170      if (set->fd_array[i] == s) return 1;
    … …  
    205210        case SOCENETRESET:      return WSAENETRESET;
    206211        case SOCECONNABORTED:   return WSAECONNABORTED;
    207         case SOCEPIPE: 
     212        case SOCEPIPE:
    208213        case SOCECONNRESET:     return WSAECONNRESET;
    209214        case SOCENOBUFS:        return WSAENOBUFS;
    … …  
    241246        case TRY_AGAIN:         return WSATRY_AGAIN;
    242247        case NO_RECOVERY:       return WSANO_RECOVERY;
    243         case NO_DATA:           return WSANO_DATA; 
     248        case NO_DATA:           return WSANO_DATA;
    244249
    245250        case 0:                 return 0;

  • trunk/src/wsock32/wsock32.cpp

    r3282 r3472  
    1 /* $Id: wsock32.cpp,v 1.27 2000-03-30 20:52:56 sandervl Exp $ */
     1/* $Id: wsock32.cpp,v 1.28 2000-05-02 13:09:44 bird Exp $ */
    22
    33/*
    … …  
    6363#include "dbglocal.h"
    6464
     65//kso: dirty fix to make this compile! not permanent!
     66BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *p);
     67#define LowPart u.LowPart
     68
    6569
    6670ODINDEBUGCHANNEL(WSOCK32-WSOCK32)
    … …  
    105109{
    106110    LPWSINFO iData;
    107    
     111
    108112    iData = (LPWSINFO)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WSINFO));
    109113    if (!iData)
    … …  
    122126    if (iData) {
    123127        ppid = lpFirstIData;
    124         while(ppid) 
     128        while(ppid)
    125129        {
    126130                iData = ppid;
    … …  
    171175        WSASetLastError(WSANOTINITIALISED);
    172176        return SOCKET_ERROR;
    173    } 
    174    else 
    175    if(WSAIsBlocking()) {
    176         WSASetLastError(WSAEINPROGRESS);
    177         return SOCKET_ERROR;
    178    } 
     177   }
     178   else
     179   if(WSAIsBlocking()) {
     180        WSASetLastError(WSAEINPROGRESS);
     181        return SOCKET_ERROR;
     182   }
    179183   ret = shutdown(s, how);
    180    
     184
    181185   if(ret == SOCKET_ERROR) {
    182186        WSASetLastError(wsaErrno());
    … …  
    197201        WSASetLastError(WSANOTINITIALISED);
    198202        return SOCKET_ERROR;
    199    } 
    200    else 
    201    if(WSAIsBlocking()) {
    202         WSASetLastError(WSAEINPROGRESS);
    203         return SOCKET_ERROR;
    204    } 
     203   }
     204   else
     205   if(WSAIsBlocking()) {
     206        WSASetLastError(WSAEINPROGRESS);
     207        return SOCKET_ERROR;
     208   }
    205209   s = socket(af, type, protocol);
    206    
     210
    207211   if(s == SOCKET_ERROR && sock_errno() == SOCEPFNOSUPPORT) {
    208212        //map SOCEPFNOSUPPORT to SOCEPFNOSUPPORT
    … …  
    225229        WSASetLastError(WSANOTINITIALISED);
    226230        return SOCKET_ERROR;
    227    } 
    228    else 
    229    if(WSAIsBlocking()) {
    230         WSASetLastError(WSAEINPROGRESS);
    231         return SOCKET_ERROR;
    232    } 
     231   }
     232   else
     233   if(WSAIsBlocking()) {
     234        WSASetLastError(WSAEINPROGRESS);
     235        return SOCKET_ERROR;
     236   }
    233237   ret = soclose(s);
    234238   //Close WSAAsyncSelect thread if one was created for this socket
    235239   FindAndSetAsyncEvent(s, 0, 0, 0);
    236  
     240
    237241   if(ret == SOCKET_ERROR) {
    238242        WSASetLastError(wsaErrno());
    … …  
    253257        WSASetLastError(WSANOTINITIALISED);
    254258        return SOCKET_ERROR;
    255    } 
    256    else 
    257    if(WSAIsBlocking()) {
    258         WSASetLastError(WSAEINPROGRESS);
    259         return SOCKET_ERROR;
    260    } 
     259   }
     260   else
     261   if(WSAIsBlocking()) {
     262        WSASetLastError(WSAEINPROGRESS);
     263        return SOCKET_ERROR;
     264   }
    261265   ret = connect(s, (sockaddr *)name, namelen);
    262266   // map BSD error codes
    … …  
    268272        if(sockerror == SOCEINPROGRESS) {
    269273                WSASetLastError(WSAEWOULDBLOCK);
    270         } 
    271         else 
     274        }
     275        else
    272276        if(sockerror == SOCEOPNOTSUPP) {
    273277                WSASetLastError(WSAEINVAL);
    … …  
    290294        WSASetLastError(WSANOTINITIALISED);
    291295        return SOCKET_ERROR;
    292    } 
    293    else 
    294    if(WSAIsBlocking()) {
    295         WSASetLastError(WSAEINPROGRESS);
    296         return SOCKET_ERROR;
    297    } 
     296   }
     297   else
     298   if(WSAIsBlocking()) {
     299        WSASetLastError(WSAEINPROGRESS);
     300        return SOCKET_ERROR;
     301   }
    298302   // clear high word (not used in OS/2's tcpip stack)
    299303   cmd = LOUSHORT(cmd);
    … …  
    354358        WSASetLastError(WSANOTINITIALISED);
    355359        return SOCKET_ERROR;
    356    } 
    357    else 
    358    if(WSAIsBlocking()) {
    359         WSASetLastError(WSAEINPROGRESS);
    360         return SOCKET_ERROR;
    361    } 
    362    else 
     360   }
     361   else
     362   if(WSAIsBlocking()) {
     363        WSASetLastError(WSAEINPROGRESS);
     364        return SOCKET_ERROR;
     365   }
     366   else
    363367   if (namelen == NULL || *namelen < (int)sizeof(struct sockaddr_in)) {
    364368        WSASetLastError(WSAEFAULT);
    … …  
    384388        WSASetLastError(WSANOTINITIALISED);
    385389        return SOCKET_ERROR;
    386    } 
    387    else 
    388    if(WSAIsBlocking()) {
    389         WSASetLastError(WSAEINPROGRESS);
    390         return SOCKET_ERROR;
    391    } 
    392    else 
     390   }
     391   else
     392   if(WSAIsBlocking()) {
     393        WSASetLastError(WSAEINPROGRESS);
     394        return SOCKET_ERROR;
     395   }
     396   else
    393397   if (namelen == NULL || *namelen < (int)sizeof(struct sockaddr_in)) {
    394398        WSASetLastError(WSAEFAULT);
    … …  
    460464        WSASetLastError(WSANOTINITIALISED);
    461465        return SOCKET_ERROR;
    462    } 
    463    else 
    464    if(WSAIsBlocking()) {
    465         WSASetLastError(WSAEINPROGRESS);
    466         return SOCKET_ERROR;
    467    } 
    468    else 
     466   }
     467   else
     468   if(WSAIsBlocking()) {
     469        WSASetLastError(WSAEINPROGRESS);
     470        return SOCKET_ERROR;
     471   }
     472   else
    469473   if ((addr != NULL) && (addrlen != NULL)) {
    470474        if (*addrlen < (int)sizeof(struct sockaddr_in)) {
    … …  
    505509        WSASetLastError(WSANOTINITIALISED);
    506510        return SOCKET_ERROR;
    507    } 
    508    else 
    509    if(WSAIsBlocking()) {
    510         WSASetLastError(WSAEINPROGRESS);
    511         return SOCKET_ERROR;
    512    } 
    513    else 
     511   }
     512   else
     513   if(WSAIsBlocking()) {
     514        WSASetLastError(WSAEINPROGRESS);
     515        return SOCKET_ERROR;
     516   }
     517   else
    514518   if(namelen < (int)sizeof(struct sockaddr_in)) {
    515519        WSASetLastError(WSAEFAULT);
    … …  
    536540        WSASetLastError(WSANOTINITIALISED);
    537541        return SOCKET_ERROR;
    538    } 
    539    else 
    540    if(WSAIsBlocking()) {
    541         WSASetLastError(WSAEINPROGRESS);
    542         return SOCKET_ERROR;
    543    } 
     542   }
     543   else
     544   if(WSAIsBlocking()) {
     545        WSASetLastError(WSAEINPROGRESS);
     546        return SOCKET_ERROR;
     547   }
    544548   namelen = sizeof(name);
    545549   ret = getsockname(s, (struct sockaddr *)&name, &namelen);
    … …  
    549553                WSASetLastError(WSAEINVAL);
    550554                return SOCKET_ERROR;
    551         } 
     555        }
    552556        ret = ioctl(s, FIOBSTATUS, (char *)&tmp, sizeof(tmp)) &
    553557                   (SS_ISCONNECTING | SS_ISCONNECTED | SS_ISDISCONNECTING);
    … …  
    579583        WSASetLastError(WSANOTINITIALISED);
    580584        return SOCKET_ERROR;
    581    } 
    582    else 
    583    if(WSAIsBlocking()) {
    584         WSASetLastError(WSAEINPROGRESS);
    585         return SOCKET_ERROR;
    586    } 
     585   }
     586   else
     587   if(WSAIsBlocking()) {
     588        WSASetLastError(WSAEINPROGRESS);
     589        return SOCKET_ERROR;
     590   }
    587591   ret = recv(s, buf, len, flags);
    588592
    … …  
    611615        WSASetLastError(WSANOTINITIALISED);
    612616        return SOCKET_ERROR;
    613    } 
    614    else 
    615    if(WSAIsBlocking()) {
    616         WSASetLastError(WSAEINPROGRESS);
    617         return SOCKET_ERROR;
    618    } 
    619    else 
     617   }
     618   else
     619   if(WSAIsBlocking()) {
     620        WSASetLastError(WSAEINPROGRESS);
     621        return SOCKET_ERROR;
     622   }
     623   else
    620624   if(fromlen == NULL || *fromlen < (int)sizeof(struct sockaddr_in)) {
    621625        WSASetLastError(WSAEFAULT);
    … …  
    646650        WSASetLastError(WSANOTINITIALISED);
    647651        return SOCKET_ERROR;
    648    } 
    649    else 
    650    if(WSAIsBlocking()) {
    651         WSASetLastError(WSAEINPROGRESS);
    652         return SOCKET_ERROR;
    653    } 
     652   }
     653   else
     654   if(WSAIsBlocking()) {
     655        WSASetLastError(WSAEINPROGRESS);
     656        return SOCKET_ERROR;
     657   }
    654658   ret = send(s, (char *)buf, len, flags);
    655659
    … …  
    678682        WSASetLastError(WSANOTINITIALISED);
    679683        return SOCKET_ERROR;
    680    } 
    681    else 
    682    if(WSAIsBlocking()) {
    683         WSASetLastError(WSAEINPROGRESS);
    684         return SOCKET_ERROR;
    685    } 
    686    else 
     684   }
     685   else
     686   if(WSAIsBlocking()) {
     687        WSASetLastError(WSAEINPROGRESS);
     688        return SOCKET_ERROR;
     689   }
     690   else
    687691   if(tolen < (int)sizeof(struct sockaddr_in)) {
    688692        WSASetLastError(WSAEFAULT);
    … …  
    719723        WSASetLastError(WSANOTINITIALISED);
    720724        return SOCKET_ERROR;
    721    } 
    722    else 
    723    if(WSAIsBlocking()) {
    724         WSASetLastError(WSAEINPROGRESS);
    725         return SOCKET_ERROR;
    726    } 
     725   }
     726   else
     727   if(WSAIsBlocking()) {
     728        WSASetLastError(WSAEINPROGRESS);
     729        return SOCKET_ERROR;
     730   }
    727731   else {
    728732        nrread = nrwrite = nrexcept = 0;
    … …  
    746750        if(timeout == NULL) {
    747751                ttimeout = -1L; // no timeout
    748         } 
     752        }
    749753        else    ttimeout = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
    750        
     754
    751755        sockets = (int *)malloc(sizeof(int) * (nrread+nrwrite+nrexcept));
    752756        if(readfds) {
    … …  
    762766        ret = select(sockets, nrread, nrwrite, nrexcept, ttimeout);
    763767
    764         if(ret == SOCKET_ERROR) 
     768        if(ret == SOCKET_ERROR)
    765769        {
    766770                if(readfds != NULL)
    … …  
    776780                free(sockets);
    777781                return SOCKET_ERROR;
    778         } 
     782        }
    779783
    780784        if(ret != 0) {
    … …  
    813817                        exceptfds->fd_count = j;
    814818                }
    815          } 
     819         }
    816820        else {
    817821            if(readfds != NULL)
    … …  
    845849        WSASetLastError(WSANOTINITIALISED);
    846850        return SOCKET_ERROR;
    847    } 
    848    else 
    849    if(WSAIsBlocking()) {
    850         WSASetLastError(WSAEINPROGRESS);
    851         return SOCKET_ERROR;
    852    } 
     851   }
     852   else
     853   if(WSAIsBlocking()) {
     854        WSASetLastError(WSAEINPROGRESS);
     855        return SOCKET_ERROR;
     856   }
    853857   if (level == SOL_SOCKET) {
    854858        switch(optname) {
    … …  
    896900                ret = setsockopt(s, level, optname, (char *)optval, optlen);
    897901                break;
    898         default: 
     902        default:
    899903                dprintf(("setsockopt: unknown option %x", optname));
    900904                WSASetLastError(WSAENOPROTOOPT);
    901905                return SOCKET_ERROR;
    902         } 
    903    }
    904    else 
     906        }
     907   }
     908   else
    905909   if(level == IPPROTO_TCP) {
    906910        if(optname == TCP_NODELAY) {
    … …  
    910914                }
    911915                ret = setsockopt(s, level, optname, (char *)optval, optlen);
    912         } 
     916        }
    913917        else {
    914918                dprintf(("setsockopt: unknown option %x", optname));
    … …  
    916920                return SOCKET_ERROR;
    917921        }
    918    } 
     922   }
    919923   else {
    920924        WSASetLastError(WSAEINVAL);
    … …  
    945949        WSASetLastError(WSANOTINITIALISED);
    946950        return SOCKET_ERROR;
    947    } 
    948    else 
    949    if(WSAIsBlocking()) {
    950         WSASetLastError(WSAEINPROGRESS);
    951         return SOCKET_ERROR;
    952    } 
     951   }
     952   else
     953   if(WSAIsBlocking()) {
     954        WSASetLastError(WSAEINPROGRESS);
     955        return SOCKET_ERROR;
     956   }
    953957   if (level == SOL_SOCKET) {
    954958        switch(optname) {
    … …  
    994998                }
    995999                break;
    996         default: 
     1000        default:
    9971001                dprintf(("getsockopt: unknown option %x", optname));
    9981002                WSASetLastError(WSAENOPROTOOPT);
    9991003                return SOCKET_ERROR;
    1000         } 
    1001    }
    1002    else 
     1004        }
     1005   }
     1006   else
    10031007   if(level == IPPROTO_TCP) {
    10041008        if(optname == TCP_NODELAY) {
    … …  
    10081012                }
    10091013                ret = getsockopt(s, level, optname, (char *)optval, optlen);
    1010         } 
     1014        }
    10111015        else {
    10121016                dprintf(("getsockopt: unknown option %x", optname));
    … …  
    10141018                return SOCKET_ERROR;
    10151019        }
    1016    } 
     1020   }
    10171021   else {
    10181022        WSASetLastError(WSAEINVAL);
    … …  
    11101114        }
    11111115        else    WSASetLastError(WSANO_DATA);
    1112     } 
     1116    }
    11131117    else WSASetLastError(WSANOTINITIALISED);
    11141118    return NULL;
    … …  
    11331137        }
    11341138        else    WSASetLastError(WSANO_DATA);
    1135     } 
     1139    }
    11361140    else WSASetLastError(WSANOTINITIALISED);
    11371141    return NULL;
Note: See TracChangeset for help on using the changeset viewer.