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.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.