Changeset 14479


Ignore:
Timestamp:
Mar 18, 2015, 7:34:26 AM (6 years ago)
Author:
mikedld
Message:

Define and use tr_socket_t and TR_BAD_SOCKET instead of int and -1.

Test socket validity by comparing to TR_BAD_SOCKET instead of various
(and sometimes wrong) other tests like x >= 0, x != -1, x > 0,
x > -1, x (valid), and x < 0, x == -1 (invalid).

Location:
trunk/libtransmission
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/announcer-udp.c

    r14476 r14479  
    5454            const void * buf, size_t buflen)
    5555{
    56     int sockfd;
     56    tr_socket_t sockfd;
    5757
    5858    if (ai->ai_addr->sa_family == AF_INET)
     
    6161        sockfd = session->udp6_socket;
    6262    else
    63         sockfd = -1;
    64 
    65     if (sockfd < 0) {
     63        sockfd = TR_BAD_SOCKET;
     64
     65    if (sockfd == TR_BAD_SOCKET) {
    6666        errno = EAFNOSUPPORT;
    6767        return -1;
  • trunk/libtransmission/fdlimit.c

    r14427 r14479  
    504504***/
    505505
    506 int
    507 tr_fdSocketCreate (tr_session * session, int domain, int type)
    508 {
    509   int s = -1;
     506tr_socket_t
     507tr_fdSocketCreate (tr_session * session,
     508                   int          domain,
     509                   int          type)
     510{
     511  tr_socket_t s = TR_BAD_SOCKET;
    510512  struct tr_fdInfo * gFd;
    511513  assert (tr_isSession (session));
     
    515517
    516518  if (gFd->peerCount < session->peerLimit)
    517     if ((s = socket (domain, type, 0)) < 0)
     519    if ((s = socket (domain, type, 0)) == TR_BAD_SOCKET)
    518520      if (sockerrno != EAFNOSUPPORT)
    519521        tr_logAddError (_("Couldn't create socket: %s"), tr_strerror (sockerrno));
    520522
    521   if (s > -1)
     523  if (s != TR_BAD_SOCKET)
    522524    ++gFd->peerCount;
    523525
    524526  assert (gFd->peerCount >= 0);
    525527
    526   if (s >= 0)
     528  if (s != TR_BAD_SOCKET)
    527529    {
    528530      static bool buf_logged = false;
     
    542544}
    543545
    544 int
    545 tr_fdSocketAccept (tr_session * s, int sockfd, tr_address * addr, tr_port * port)
    546 {
    547   int fd;
     546tr_socket_t
     547tr_fdSocketAccept (tr_session  * s,
     548                   tr_socket_t   sockfd,
     549                   tr_address  * addr,
     550                   tr_port     * port)
     551{
     552  tr_socket_t fd;
    548553  socklen_t len;
    549554  struct tr_fdInfo * gFd;
     
    560565  fd = accept (sockfd, (struct sockaddr *) &sock, &len);
    561566
    562   if (fd >= 0)
     567  if (fd != TR_BAD_SOCKET)
    563568    {
    564569      if ((gFd->peerCount < s->peerLimit)
     
    567572          ++gFd->peerCount;
    568573        }
    569         else
     574      else
    570575        {
    571576          tr_netCloseSocket (fd);
    572           fd = -1;
     577          fd = TR_BAD_SOCKET;
    573578        }
    574579    }
     
    578583
    579584void
    580 tr_fdSocketClose (tr_session * session, int fd)
     585tr_fdSocketClose (tr_session  * session,
     586                  tr_socket_t   fd)
    581587{
    582588  assert (tr_isSession (session));
     
    586592      struct tr_fdInfo * gFd = session->fdInfo;
    587593
    588       if (fd >= 0)
     594      if (fd != TR_BAD_SOCKET)
    589595        {
    590596          tr_netCloseSocket (fd);
  • trunk/libtransmission/fdlimit.h

    r14327 r14479  
    8181 * Sockets
    8282 **********************************************************************/
    83 int      tr_fdSocketCreate (tr_session * session, int domain, int type);
     83tr_socket_t tr_fdSocketCreate (tr_session  * session,
     84                               int           domain,
     85                               int           type);
    8486
    85 int      tr_fdSocketAccept (tr_session  * session,
    86                             int           listening_sockfd,
    87                             tr_address  * addr,
    88                             tr_port     * port);
     87tr_socket_t tr_fdSocketAccept (tr_session  * session,
     88                               tr_socket_t   listening_sockfd,
     89                               tr_address  * addr,
     90                               tr_port     * port);
    8991
    90 void     tr_fdSocketClose (tr_session * session, int s);
     92void        tr_fdSocketClose  (tr_session  * session,
     93                               tr_socket_t   s);
    9194
    9295/***********************************************************************
  • trunk/libtransmission/natpmp.c

    r14241 r14479  
    8585    nat->public_port = 0;
    8686    nat->private_port = 0;
    87     nat->natpmp.s = -1; /* socket */
     87    nat->natpmp.s = TR_BAD_SOCKET; /* socket */
    8888    return nat;
    8989}
     
    9494    if (nat)
    9595    {
    96         if (nat->natpmp.s >= 0)
    97             tr_netCloseSocket (nat->natpmp.s);
     96        closenatpmp (&nat->natpmp);
    9897        tr_free (nat);
    9998    }
  • trunk/libtransmission/net.c

    r14427 r14479  
    146146
    147147int
    148 tr_netSetTOS (int s, int tos)
     148tr_netSetTOS (tr_socket_t s,
     149              int         tos)
    149150{
    150151#ifdef IP_TOS
     
    156157
    157158int
    158 tr_netSetCongestionControl (int s UNUSED, const char *algorithm UNUSED)
     159tr_netSetCongestionControl (tr_socket_t   s UNUSED,
     160                            const char  * algorithm UNUSED)
    159161{
    160162#ifdef TCP_CONGESTION
     
    223225}
    224226
    225 int
     227tr_socket_t
    226228tr_netOpenPeerSocket (tr_session        * session,
    227229                      const tr_address  * addr,
     
    230232{
    231233    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
    232     int                     s;
     234    tr_socket_t             s;
    233235    struct sockaddr_storage sock;
    234236    socklen_t               addrlen;
     
    243245
    244246    s = tr_fdSocketCreate (session, domains[addr->type], SOCK_STREAM);
    245     if (s < 0)
    246         return -1;
     247    if (s == TR_BAD_SOCKET)
     248        return TR_BAD_SOCKET;
    247249
    248250    /* seeds don't need much of a read buffer... */
     
    250252        int n = 8192;
    251253        if (setsockopt (s, SOL_SOCKET, SO_RCVBUF, (const void *) &n, sizeof (n)))
    252             tr_logAddInfo ("Unable to set SO_RCVBUF on socket %d: %s", s, tr_strerror (sockerrno));
     254            tr_logAddInfo ("Unable to set SO_RCVBUF on socket %"TR_PRI_SOCK": %s", s, tr_strerror (sockerrno));
    253255    }
    254256
    255257    if (evutil_make_socket_nonblocking (s) < 0) {
    256258        tr_netClose (session, s);
    257         return -1;
     259        return TR_BAD_SOCKET;
    258260    }
    259261
     
    266268    if (bind (s, (struct sockaddr *) &source_sock, sourcelen))
    267269    {
    268         tr_logAddError (_("Couldn't set source address %s on %d: %s"),
     270        tr_logAddError (_("Couldn't set source address %s on %"TR_PRI_SOCK": %s"),
    269271                tr_address_to_string (source_addr), s, tr_strerror (errno));
    270272        tr_netClose (session, s);
    271         return -errno;
     273        return TR_BAD_SOCKET; /* -errno */
    272274    }
    273275
     
    283285        if ((tmperrno != ENETUNREACH && tmperrno != EHOSTUNREACH)
    284286                || addr->type == TR_AF_INET)
    285             tr_logAddError (_("Couldn't connect socket %d to %s, port %d (errno %d - %s)"),
     287            tr_logAddError (_("Couldn't connect socket %"TR_PRI_SOCK" to %s, port %d (errno %d - %s)"),
    286288                    s, tr_address_to_string (addr), (int)ntohs (port), tmperrno,
    287289                    tr_strerror (tmperrno));
    288290        tr_netClose (session, s);
    289         s = -tmperrno;
    290     }
    291 
    292     tr_logAddDeep (__FILE__, __LINE__, NULL, "New OUTGOING connection %d (%s)",
     291        s = TR_BAD_SOCKET; /* -tmperrno */
     292    }
     293
     294    tr_logAddDeep (__FILE__, __LINE__, NULL, "New OUTGOING connection %"TR_PRI_SOCK" (%s)",
    293295                   s, tr_peerIoAddrStr (addr, port));
    294296
     
    314316}
    315317
    316 static int
    317 tr_netBindTCPImpl (const tr_address * addr, tr_port port, bool suppressMsgs, int * errOut)
     318static tr_socket_t
     319tr_netBindTCPImpl (const tr_address * addr,
     320                   tr_port            port,
     321                   bool               suppressMsgs,
     322                   int              * errOut)
    318323{
    319324    static const int domains[NUM_TR_AF_INET_TYPES] = { AF_INET, AF_INET6 };
    320325    struct sockaddr_storage sock;
    321     int fd;
     326    tr_socket_t fd;
    322327    int addrlen;
    323328    int optval;
     
    326331
    327332    fd = socket (domains[addr->type], SOCK_STREAM, 0);
    328     if (fd < 0) {
     333    if (fd == TR_BAD_SOCKET) {
    329334        *errOut = sockerrno;
    330         return -1;
     335        return TR_BAD_SOCKET;
    331336    }
    332337
     
    334339        *errOut = sockerrno;
    335340        tr_netCloseSocket (fd);
    336         return -1;
     341        return TR_BAD_SOCKET;
    337342    }
    338343
     
    346351            if (sockerrno != ENOPROTOOPT) { /* if the kernel doesn't support it, ignore it */
    347352                *errOut = sockerrno;
    348                 return -1;
     353                return TR_BAD_SOCKET;
    349354            }
    350355#endif
     
    372377        tr_netCloseSocket (fd);
    373378        *errOut = err;
    374         return -1;
     379        return TR_BAD_SOCKET;
    375380    }
    376381
    377382    if (!suppressMsgs)
    378         tr_logAddDebug ("Bound socket %d to port %d on %s", fd, port, tr_address_to_string (addr));
     383        tr_logAddDebug ("Bound socket %"TR_PRI_SOCK" to port %d on %s", fd, port, tr_address_to_string (addr));
    379384
    380385    if (listen (fd, 128) == -1) {
    381386        *errOut = sockerrno;
    382387        tr_netCloseSocket (fd);
    383         return -1;
     388        return TR_BAD_SOCKET;
    384389    }
    385390
     
    387392}
    388393
    389 int
    390 tr_netBindTCP (const tr_address * addr, tr_port port, bool suppressMsgs)
     394tr_socket_t
     395tr_netBindTCP (const tr_address * addr,
     396               tr_port            port,
     397               bool               suppressMsgs)
    391398{
    392399    int unused;
     
    403410    {
    404411        int err;
    405         int fd = tr_netBindTCPImpl (&tr_in6addr_any, port, true, &err);
    406         if (fd >= 0 || err != EAFNOSUPPORT) /* we support ipv6 */
     412        tr_socket_t fd = tr_netBindTCPImpl (&tr_in6addr_any, port, true, &err);
     413        if (fd != TR_BAD_SOCKET || err != EAFNOSUPPORT) /* we support ipv6 */
    407414            result = true;
    408         if (fd >= 0)
     415        if (fd != TR_BAD_SOCKET)
    409416            tr_netCloseSocket (fd);
    410417        alreadyDone = true;
     
    414421}
    415422
    416 int
     423tr_socket_t
    417424tr_netAccept (tr_session  * session,
    418               int           b,
     425              tr_socket_t   b,
    419426              tr_address  * addr,
    420427              tr_port     * port)
    421428{
    422     int fd = tr_fdSocketAccept (session, b, addr, port);
    423 
    424     if (fd>=0 && evutil_make_socket_nonblocking (fd)<0) {
     429    tr_socket_t fd = tr_fdSocketAccept (session, b, addr, port);
     430
     431    if (fd != TR_BAD_SOCKET && evutil_make_socket_nonblocking (fd) < 0) {
    425432        tr_netClose (session, fd);
    426         fd = -1;
     433        fd = TR_BAD_SOCKET;
    427434    }
    428435
     
    431438
    432439void
    433 tr_netCloseSocket (int fd)
     440tr_netCloseSocket (tr_socket_t fd)
    434441{
    435442    evutil_closesocket (fd);
     
    437444
    438445void
    439 tr_netClose (tr_session * session, int s)
     446tr_netClose (tr_session  * session,
     447             tr_socket_t   s)
    440448{
    441449    tr_fdSocketClose (session, s);
     
    458466                    socklen_t              * src_len)
    459467{
    460     int s, rc, save;
     468    tr_socket_t s;
     469    int rc, save;
    461470
    462471    s = socket (dst->sa_family, SOCK_DGRAM, 0);
    463     if (s < 0)
     472    if (s == TR_BAD_SOCKET)
    464473        goto fail;
    465474
  • trunk/libtransmission/net.h

    r14428 r14479  
    3434 #include <ws2tcpip.h>
    3535#else
     36 #include <errno.h>
    3637 #include <sys/socket.h>
    3738 #include <netinet/in.h>
     
    3940
    4041#ifdef _WIN32
     42 typedef SOCKET tr_socket_t;
     43 #define TR_BAD_SOCKET INVALID_SOCKET
     44 #define TR_PRI_SOCK "Id" /* intentionally signed to print -1 nicely. */
     45
    4146 #undef  EADDRINUSE
    4247 #define EADDRINUSE              WSAEADDRINUSE
     
    5762 #undef  ENETUNREACH
    5863 #define ENETUNREACH             WSAENETUNREACH
     64
    5965 #define sockerrno               WSAGetLastError ()
    6066#else
    61  #include <errno.h>
     67 /** @brief Platform-specific socket descriptor type. */
     68 typedef int tr_socket_t;
     69 /** @brief Platform-specific invalid socket descriptor constant. */
     70 #define TR_BAD_SOCKET (-1)
     71 #define TR_PRI_SOCK "d"
     72
    6273 #define sockerrno errno
    6374#endif
     
    122133struct tr_session;
    123134
    124 int tr_netOpenPeerSocket (tr_session       * session,
    125                            const tr_address * addr,
    126                            tr_port            port,
    127                            bool               clientIsSeed);
     135tr_socket_t tr_netOpenPeerSocket (tr_session       * session,
     136                                  const tr_address * addr,
     137                                  tr_port            port,
     138                                  bool               clientIsSeed);
    128139
    129140struct UTPSocket *
     
    133144                         bool                clientIsSeed);
    134145
    135 int tr_netBindTCP (const tr_address * addr,
    136                     tr_port            port,
    137                     bool               suppressMsgs);
     146tr_socket_t tr_netBindTCP (const tr_address * addr,
     147                           tr_port            port,
     148                           bool               suppressMsgs);
    138149
    139 int  tr_netAccept (tr_session * session,
    140                    int          bound,
    141                    tr_address * setme_addr,
    142                    tr_port    * setme_port);
     150tr_socket_t tr_netAccept (tr_session * session,
     151                          tr_socket_t   bound,
     152                          tr_address * setme_addr,
     153                          tr_port     * setme_port);
    143154
    144 int  tr_netSetTOS (int s,
    145                    int tos);
     155int  tr_netSetTOS (tr_socket_t s,
     156                   int         tos);
    146157
    147 int tr_netSetCongestionControl (int s, const char *algorithm);
     158int tr_netSetCongestionControl (tr_socket_t   s,
     159                                const char  * algorithm);
    148160
    149 void tr_netClose (tr_session * session, int s);
     161void tr_netClose (tr_session  * session,
     162                  tr_socket_t   s);
    150163
    151 void tr_netCloseSocket (int fd);
     164void tr_netCloseSocket (tr_socket_t fd);
    152165
    153166void tr_netInit (void);
  • trunk/libtransmission/peer-io.c

    r14476 r14479  
    159159        /* For uTP sockets, the overhead is computed in utp_on_overhead. */
    160160        const unsigned int overhead =
    161             io->socket ? guessPacketOverhead (payload) : 0;
     161            io->socket != TR_BAD_SOCKET ? guessPacketOverhead (payload) : 0;
    162162        const uint64_t now = tr_time_msec ();
    163163
     
    260260
    261261    assert (tr_isPeerIo (io));
    262     assert (io->socket >= 0);
     262    assert (io->socket != TR_BAD_SOCKET);
    263263
    264264    io->pendingEvents &= ~EV_READ;
     
    337337
    338338    assert (tr_isPeerIo (io));
    339     assert (io->socket >= 0);
     339    assert (io->socket != TR_BAD_SOCKET);
    340340
    341341    io->pendingEvents &= ~EV_WRITE;
     
    394394
    395395static void
    396 maybeSetCongestionAlgorithm (int socket, const char * algorithm)
     396maybeSetCongestionAlgorithm (tr_socket_t   socket,
     397                             const char  * algorithm)
    397398{
    398399    if (algorithm && *algorithm)
     
    595596              bool               isIncoming,
    596597              bool               isSeed,
    597               int                socket,
     598              tr_socket_t        socket,
    598599              struct UTPSocket * utp_socket)
    599600{
     
    605606    assert (tr_isBool (isSeed));
    606607    assert (tr_amInEventThread (session));
    607     assert ((socket < 0) == (utp_socket != NULL));
     608    assert ((socket == TR_BAD_SOCKET) == (utp_socket != NULL));
    608609#ifndef WITH_UTP
    609     assert (socket >= 0);
     610    assert (socket != TR_BAD_SOCKET);
    610611#endif
    611612
    612     if (socket >= 0) {
     613    if (socket != TR_BAD_SOCKET) {
    613614        tr_netSetTOS (socket, session->peerSocketTOS);
    614615        maybeSetCongestionAlgorithm (socket, session->peer_congestion_algorithm);
     
    632633    tr_bandwidthSetPeer (&io->bandwidth, io);
    633634    dbgmsg (io, "bandwidth is %p; its parent is %p", (void*)&io->bandwidth, (void*)parent);
    634     dbgmsg (io, "socket is %d, utp_socket is %p", socket, (void*)utp_socket);
    635 
    636     if (io->socket >= 0) {
     635    dbgmsg (io, "socket is %"TR_PRI_SOCK", utp_socket is %p", socket, (void*)utp_socket);
     636
     637    if (io->socket != TR_BAD_SOCKET) {
    637638        io->event_read = event_new (session->event_base,
    638639                                    io->socket, EV_READ, event_read_cb, io);
     
    662663                      const tr_address  * addr,
    663664                      tr_port             port,
    664                       int                 fd,
     665                      tr_socket_t         fd,
    665666                      struct UTPSocket  * utp_socket)
    666667{
     
    681682                      bool                utp)
    682683{
    683     int fd = -1;
     684    tr_socket_t fd = TR_BAD_SOCKET;
    684685    struct UTPSocket * utp_socket = NULL;
    685686
     
    693694    if (!utp_socket) {
    694695        fd = tr_netOpenPeerSocket (session, addr, port, isSeed);
    695         dbgmsg (NULL, "tr_netOpenPeerSocket returned fd %d", fd);
    696     }
    697 
    698     if (fd < 0 && utp_socket == NULL)
     696        dbgmsg (NULL, "tr_netOpenPeerSocket returned fd %"TR_PRI_SOCK, fd);
     697    }
     698
     699    if (fd == TR_BAD_SOCKET && utp_socket == NULL)
    699700        return NULL;
    700701
     
    714715    assert (io->session->events != NULL);
    715716
    716     if (io->socket >= 0)
     717    if (io->socket != TR_BAD_SOCKET)
    717718    {
    718719        assert (event_initialized (io->event_read));
     
    723724    {
    724725        dbgmsg (io, "enabling ready-to-read polling");
    725         if (io->socket >= 0)
     726        if (io->socket != TR_BAD_SOCKET)
    726727            event_add (io->event_read, NULL);
    727728        io->pendingEvents |= EV_READ;
     
    731732    {
    732733        dbgmsg (io, "enabling ready-to-write polling");
    733         if (io->socket >= 0)
     734        if (io->socket != TR_BAD_SOCKET)
    734735            event_add (io->event_write, NULL);
    735736        io->pendingEvents |= EV_WRITE;
     
    744745    assert (io->session->events != NULL);
    745746
    746     if (io->socket >= 0)
     747    if (io->socket != TR_BAD_SOCKET)
    747748    {
    748749        assert (event_initialized (io->event_read));
     
    753754    {
    754755        dbgmsg (io, "disabling ready-to-read polling");
    755         if (io->socket >= 0)
     756        if (io->socket != TR_BAD_SOCKET)
    756757            event_del (io->event_read);
    757758        io->pendingEvents &= ~EV_READ;
     
    761762    {
    762763        dbgmsg (io, "disabling ready-to-write polling");
    763         if (io->socket >= 0)
     764        if (io->socket != TR_BAD_SOCKET)
    764765            event_del (io->event_write);
    765766        io->pendingEvents &= ~EV_WRITE;
     
    791792io_close_socket (tr_peerIo * io)
    792793{
    793     if (io->socket >= 0) {
     794    if (io->socket != TR_BAD_SOCKET) {
    794795        tr_netClose (io->session, io->socket);
    795         io->socket = -1;
     796        io->socket = TR_BAD_SOCKET;
    796797    }
    797798
     
    943944    io->event_write = event_new (session->event_base, io->socket, EV_WRITE, event_write_cb, io);
    944945
    945     if (io->socket >= 0)
     946    if (io->socket != TR_BAD_SOCKET)
    946947    {
    947948        event_enable (io, pendingEvents);
  • trunk/libtransmission/peer-io.h

    r14347 r14479  
    8787
    8888    tr_port               port;
    89     int                   socket;
     89    tr_socket_t           socket;
    9090    struct UTPSocket    * utp_socket;
    9191
     
    133133                                  const struct tr_address * addr,
    134134                                  tr_port                   port,
    135                                   int                       socket,
     135                                  tr_socket_t               socket,
    136136                                  struct UTPSocket *        utp_socket);
    137137
  • trunk/libtransmission/peer-mgr.c

    r14428 r14479  
    20562056                       tr_address       * addr,
    20572057                       tr_port            port,
    2058                        int                socket,
     2058                       tr_socket_t        socket,
    20592059                       struct UTPSocket * utp_socket)
    20602060{
     
    20692069    {
    20702070      tr_logAddDebug ("Banned IP address \"%s\" tried to connect to us", tr_address_to_string (addr));
    2071       if (socket >= 0)
     2071      if (socket != TR_BAD_SOCKET)
    20722072        tr_netClose (session, socket);
    20732073      else
     
    20762076  else if (getExistingHandshake (&manager->incomingHandshakes, addr))
    20772077    {
    2078       if (socket >= 0)
     2078      if (socket != TR_BAD_SOCKET)
    20792079        tr_netClose (session, socket);
    20802080      else
  • trunk/libtransmission/peer-mgr.h

    r14428 r14479  
    108108                                             tr_address          * addr,
    109109                                             tr_port               port,
    110                                              int                   socket,
     110                                             tr_socket_t           socket,
    111111                                             struct UTPSocket    * utp_socket);
    112112
  • trunk/libtransmission/session.c

    r14428 r14479  
    143143struct tr_bindinfo
    144144{
    145   int socket;
     145  tr_socket_t socket;
    146146  tr_address addr;
    147147  struct event * ev;
     
    152152close_bindinfo (struct tr_bindinfo * b)
    153153{
    154   if ((b != NULL) && (b->socket >=0))
     154  if ((b != NULL) && (b->socket != TR_BAD_SOCKET))
    155155    {
    156156      event_free (b->ev);
     
    182182accept_incoming_peer (evutil_socket_t fd, short what UNUSED, void * vsession)
    183183{
    184   int clientSocket;
     184  tr_socket_t clientSocket;
    185185  tr_port clientPort;
    186186  tr_address clientAddr;
     
    188188
    189189  clientSocket = tr_netAccept (session, fd, &clientAddr, &clientPort);
    190   if (clientSocket > 0)
    191     {
    192       tr_logAddDeep (__FILE__, __LINE__, NULL, "new incoming connection %d (%s)",
     190  if (clientSocket != TR_BAD_SOCKET)
     191    {
     192      tr_logAddDeep (__FILE__, __LINE__, NULL, "new incoming connection %"TR_PRI_SOCK" (%s)",
    193193                       clientSocket, tr_peerIoAddrStr (&clientAddr, clientPort));
    194194      tr_peerMgrAddIncoming (session->peerMgr, &clientAddr, clientPort,
     
    205205  b = session->public_ipv4;
    206206  b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
    207   if (b->socket >= 0)
     207  if (b->socket != TR_BAD_SOCKET)
    208208    {
    209209      b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
     
    216216      b = session->public_ipv6;
    217217      b->socket = tr_netBindTCP (&b->addr, session->private_peer_port, false);
    218       if (b->socket >= 0)
     218      if (b->socket != TR_BAD_SOCKET)
    219219        {
    220220          b->ev = event_new (session->event_base, b->socket, EV_READ | EV_PERSIST, accept_incoming_peer, session);
     
    595595  /* initialize the bare skeleton of the session object */
    596596  session = tr_new0 (tr_session, 1);
    597   session->udp_socket = -1;
    598   session->udp6_socket = -1;
     597  session->udp_socket = TR_BAD_SOCKET;
     598  session->udp6_socket = TR_BAD_SOCKET;
    599599  session->lock = tr_lockNew ();
    600600  session->cache = tr_cacheNew (1024*1024*2);
     
    855855  if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET))
    856856    b.addr = tr_inaddr_any;
    857   b.socket = -1;
     857  b.socket = TR_BAD_SOCKET;
    858858  session->public_ipv4 = tr_memdup (&b, sizeof (struct tr_bindinfo));
    859859
     
    861861  if (!tr_address_from_string (&b.addr, str) || (b.addr.type != TR_AF_INET6))
    862862    b.addr = tr_in6addr_any;
    863   b.socket = -1;
     863  b.socket = TR_BAD_SOCKET;
    864864  session->public_ipv6 = tr_memdup (&b, sizeof (struct tr_bindinfo));
    865865
  • trunk/libtransmission/session.h

    r14241 r14479  
    2727#include "bandwidth.h"
    2828#include "bitfield.h"
     29#include "net.h"
    2930#include "utils.h"
    3031#include "variant.h"
     
    151152    /* The UDP sockets used for the DHT and uTP. */
    152153    tr_port                      udp_port;
    153     int                          udp_socket;
    154     int                          udp6_socket;
     154    tr_socket_t                  udp_socket;
     155    tr_socket_t                  udp6_socket;
    155156    unsigned char *              udp6_bound;
    156157    struct event                 *udp_event;
  • trunk/libtransmission/tr-dht.c

    r14382 r14479  
    286286        if (have_id && len==20)
    287287            memcpy (myid, raw, len);
    288         if (ss->udp_socket >= 0 &&
     288        if (ss->udp_socket != TR_BAD_SOCKET &&
    289289            tr_variantDictFindRaw (&benc, TR_KEY_nodes, &raw, &len) && ! (len%6)) {
    290290                nodes = tr_memdup (raw, len);
    291291        }
    292         if (ss->udp6_socket > 0 &&
     292        if (ss->udp6_socket != TR_BAD_SOCKET &&
    293293            tr_variantDictFindRaw (&benc, TR_KEY_nodes6, &raw, &len6) && ! (len6%18)) {
    294294            nodes6 = tr_memdup (raw, len6);
     
    436436
    437437    if (!tr_dhtEnabled (session) ||
    438       (af == AF_INET && session->udp_socket < 0) ||
    439       (af == AF_INET6 && session->udp6_socket < 0)) {
     438      (af == AF_INET && session->udp_socket == TR_BAD_SOCKET) ||
     439      (af == AF_INET6 && session->udp6_socket == TR_BAD_SOCKET)) {
    440440        if (nodes_return)
    441441            *nodes_return = 0;
  • trunk/libtransmission/tr-lpd.c

    r14428 r14479  
    7474static struct event * upkeep_timer = NULL;
    7575
    76 static int lpd_socket; /**<separate multicast receive socket */
    77 static int lpd_socket2; /**<and multicast send socket */
     76static tr_socket_t lpd_socket; /**<separate multicast receive socket */
     77static tr_socket_t lpd_socket2; /**<and multicast send socket */
    7878static struct event * lpd_event = NULL;
    7979static tr_port lpd_port;
     
    286286    {
    287287        lpd_socket = socket (PF_INET, SOCK_DGRAM, 0);
    288         if (lpd_socket < 0)
     288        if (lpd_socket == TR_BAD_SOCKET)
    289289            goto fail;
    290290
     
    325325
    326326        lpd_socket2 = socket (PF_INET, SOCK_DGRAM, 0);
    327         if (lpd_socket2 < 0)
     327        if (lpd_socket2 == TR_BAD_SOCKET)
    328328            goto fail;
    329329
     
    361361        evutil_closesocket (lpd_socket);
    362362        evutil_closesocket (lpd_socket2);
    363         lpd_socket = lpd_socket2 = -1;
     363        lpd_socket = lpd_socket2 = TR_BAD_SOCKET;
    364364        session = NULL;
    365365        tr_logAddNamedDbg ("LPD", "LPD initialisation failed (errno = %d)", save);
  • trunk/libtransmission/tr-udp.c

    r14427 r14479  
    5252
    5353static void
    54 set_socket_buffers (int fd, int large)
     54set_socket_buffers (tr_socket_t fd,
     55                    int         large)
    5556{
    5657    int size, rbuf, sbuf, rc;
     
    106107{
    107108    bool utp = tr_sessionIsUTPEnabled (session);
    108     if (session->udp_socket >= 0)
     109    if (session->udp_socket != TR_BAD_SOCKET)
    109110        set_socket_buffers (session->udp_socket, utp);
    110     if (session->udp6_socket >= 0)
     111    if (session->udp6_socket != TR_BAD_SOCKET)
    111112        set_socket_buffers (session->udp6_socket, utp);
    112113}
     
    125126    struct sockaddr_in6 sin6;
    126127    const unsigned char *ipv6 = tr_globalIPv6 ();
    127     int s = -1, rc;
     128    tr_socket_t s = TR_BAD_SOCKET;
     129    int rc;
    128130    int one = 1;
    129131
    130132    /* We currently have no way to enable or disable IPv6 after initialisation.
    131133       No way to fix that without some surgery to the DHT code itself. */
    132     if (ipv6 == NULL || (!force && ss->udp6_socket < 0)) {
     134    if (ipv6 == NULL || (!force && ss->udp6_socket == TR_BAD_SOCKET)) {
    133135        if (ss->udp6_bound) {
    134136            free (ss->udp6_bound);
     
    142144
    143145    s = socket (PF_INET6, SOCK_DGRAM, 0);
    144     if (s < 0)
     146    if (s == TR_BAD_SOCKET)
    145147        goto fail;
    146148
     
    164166        goto fail;
    165167
    166     if (ss->udp6_socket < 0) {
     168    if (ss->udp6_socket == TR_BAD_SOCKET) {
    167169        ss->udp6_socket = s;
    168170    } else {
     
    185187       set things up so that we try again next time. */
    186188    tr_logAddNamedError ("UDP", "Couldn't rebind IPv6 socket");
    187     if (s >= 0)
     189    if (s != TR_BAD_SOCKET)
    188190        tr_netCloseSocket (s);
    189191    if (ss->udp6_bound) {
     
    245247    int rc;
    246248
    247     assert (ss->udp_socket < 0);
    248     assert (ss->udp6_socket < 0);
     249    assert (ss->udp_socket == TR_BAD_SOCKET);
     250    assert (ss->udp6_socket == TR_BAD_SOCKET);
    249251
    250252    ss->udp_port = tr_sessionGetPeerPort (ss);
     
    253255
    254256    ss->udp_socket = socket (PF_INET, SOCK_DGRAM, 0);
    255     if (ss->udp_socket < 0) {
     257    if (ss->udp_socket == TR_BAD_SOCKET) {
    256258        tr_logAddNamedError ("UDP", "Couldn't create IPv4 socket");
    257259        goto ipv6;
     
    268270        tr_logAddNamedError ("UDP", "Couldn't bind IPv4 socket");
    269271        tr_netCloseSocket (ss->udp_socket);
    270         ss->udp_socket = -1;
     272        ss->udp_socket = TR_BAD_SOCKET;
    271273        goto ipv6;
    272274    }
     
    280282    if (tr_globalIPv6 ())
    281283        rebind_ipv6 (ss, true);
    282     if (ss->udp6_socket >= 0) {
     284    if (ss->udp6_socket != TR_BAD_SOCKET) {
    283285        ss->udp6_event =
    284286            event_new (ss->event_base, ss->udp6_socket, EV_READ | EV_PERSIST,
     
    304306    tr_dhtUninit (ss);
    305307
    306     if (ss->udp_socket >= 0) {
     308    if (ss->udp_socket != TR_BAD_SOCKET) {
    307309        tr_netCloseSocket (ss->udp_socket);
    308         ss->udp_socket = -1;
     310        ss->udp_socket = TR_BAD_SOCKET;
    309311    }
    310312
     
    314316    }
    315317
    316     if (ss->udp6_socket >= 0) {
     318    if (ss->udp6_socket != TR_BAD_SOCKET) {
    317319        tr_netCloseSocket (ss->udp6_socket);
    318         ss->udp6_socket = -1;
     320        ss->udp6_socket = TR_BAD_SOCKET;
    319321    }
    320322
  • trunk/libtransmission/tr-utp.c

    r14427 r14479  
    122122    }
    123123
    124     tr_peerMgrAddIncoming (ss->peerMgr, &addr, port, -1, s);
     124    tr_peerMgrAddIncoming (ss->peerMgr, &addr, port, TR_BAD_SOCKET, s);
    125125}
    126126
     
    131131    tr_session *ss = closure;
    132132
    133     if (to->sa_family == AF_INET && ss->udp_socket)
     133    if (to->sa_family == AF_INET && ss->udp_socket != TR_BAD_SOCKET)
    134134        sendto (ss->udp_socket, (const void *) buf, buflen, 0, to, tolen);
    135     else if (to->sa_family == AF_INET6 && ss->udp_socket)
     135    else if (to->sa_family == AF_INET6 && ss->udp6_socket != TR_BAD_SOCKET)
    136136        sendto (ss->udp6_socket, (const void *) buf, buflen, 0, to, tolen);
    137137}
  • trunk/libtransmission/trevent.c

    r14428 r14479  
    3636#ifdef _WIN32
    3737
     38typedef SOCKET tr_pipe_end_t;
     39
    3840static int
    39 pgpipe (int handles[2])
     41pgpipe (tr_pipe_end_t handles[2])
    4042{
    4143    SOCKET s;
     
    99101
    100102static int
    101 piperead (int s, char *buf, int len)
     103piperead (tr_pipe_end_t   s,
     104          void          * buf,
     105          int             len)
    102106{
    103107    int ret = recv (s, buf, len, 0);
     
    127131
    128132#else
     133typedef int tr_pipe_end_t;
    129134#define piperead(a,b,c) read (a,b,c)
    130135#define pipewrite(a,b,c) write (a,b,c)
     
    138143{
    139144    uint8_t      die;
    140     int          fds[2];
     145    tr_pipe_end_t fds[2];
    141146    tr_lock *    lock;
    142147    tr_session *  session;
     
    315320  else
    316321    {
    317       int fd;
     322      tr_pipe_end_t fd;
    318323      char ch;
    319324      ssize_t res_1;
Note: See TracChangeset for help on using the changeset viewer.