release/src/router/transmission/third-party/miniupnp/minissdpc.c

   1 /* $Id: minissdpc.c,v 1.13 2009/12/04 16:57:29 nanard Exp $ */
   2 /* Project : miniupnp
   3  * Author : Thomas BERNARD
   4  * copyright (c) 2005-2009 Thomas Bernard
   5  * This software is subjet to the conditions detailed in the
   6  * provided LICENCE file. */
   7 /*#include <syslog.h>*/
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <sys/types.h>
  13 #if defined(WIN32) || defined(__amigaos__) || defined(__amigaos4__)
  14 #ifdef WIN32
  15 #include <winsock2.h>
  16 #include <ws2tcpip.h>
  17 #include <io.h>
  18 #endif
  19 #if defined(__amigaos__) || defined(__amigaos4__)
  20 #include <sys/socket.h>
  21 #endif
  22 #if defined(__amigaos__)
  23 #define uint16_t unsigned short
  24 #endif
  25 /* Hack */
  26 #define UNIX_PATH_LEN   108
  27 struct sockaddr_un {
  28   uint16_t sun_family;
  29   char     sun_path[UNIX_PATH_LEN];
  30 };
  31 #else
  32 #include <sys/socket.h>
  33 #include <sys/un.h>
  34 #endif
  35
  36 #include "minissdpc.h"
  37 #include "miniupnpc.h"
  38
  39 #include "codelength.h"
  40
  41 struct UPNPDev *
  42 getDevicesFromMiniSSDPD(const char * devtype, const char * socketpath)
  43 {
  44         struct UPNPDev * tmp;
  45         struct UPNPDev * devlist = NULL;
  46         unsigned char buffer[2048];
  47         ssize_t n;
  48         unsigned char * p;
  49         unsigned char * url;
  50         unsigned int i;
  51         unsigned int urlsize, stsize, usnsize, l;
  52         int s;
  53         struct sockaddr_un addr;
  54
  55         s = socket(AF_UNIX, SOCK_STREAM, 0);
  56         if(s < 0)
  57         {
  58                 /*syslog(LOG_ERR, "socket(unix): %m");*/
  59                 perror("socket(unix)");
  60                 return NULL;
  61         }
  62         addr.sun_family = AF_UNIX;
  63         strncpy(addr.sun_path, socketpath, sizeof(addr.sun_path));
  64         /* TODO : check if we need to handle the EINTR */
  65         if(connect(s, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
  66         {
  67                 /*syslog(LOG_WARNING, "connect(\"%s\"): %m", socketpath);*/
  68                 close(s);
  69                 return NULL;
  70         }
  71         stsize = strlen(devtype);
  72         buffer[0] = 1; /* request type 1 : request devices/services by type */
  73         p = buffer + 1;
  74         l = stsize;     CODELENGTH(l, p);
  75         if(p + stsize > buffer + sizeof(buffer))
  76         {
  77                 /* devtype is too long ! */
  78                 close(s);
  79                 return NULL;
  80         }
  81         memcpy(p, devtype, stsize);
  82         p += stsize;
  83         if(write(s, buffer, p - buffer) < 0)
  84         {
  85                 /*syslog(LOG_ERR, "write(): %m");*/
  86                 perror("minissdpc.c: write()");
  87                 close(s);
  88                 return NULL;
  89         }
  90         n = read(s, buffer, sizeof(buffer));
  91         if(n<=0)
  92         {
  93                 perror("minissdpc.c: read()");
  94                 close(s);
  95                 return NULL;
  96         }
  97         p = buffer + 1;
  98         for(i = 0; i < buffer[0]; i++)
  99         {
 100                 if(p+2>=buffer+sizeof(buffer))
 101                         break;
 102                 DECODELENGTH(urlsize, p);
 103                 if(p+urlsize+2>=buffer+sizeof(buffer))
 104                         break;
 105                 url = p;
 106                 p += urlsize;
 107                 DECODELENGTH(stsize, p);
 108                 if(p+stsize+2>=buffer+sizeof(buffer))
 109                         break;
 110                 tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
 111                 tmp->pNext = devlist;
 112                 tmp->descURL = tmp->buffer;
 113                 tmp->st = tmp->buffer + 1 + urlsize;
 114                 memcpy(tmp->buffer, url, urlsize);
 115                 tmp->buffer[urlsize] = '\0';
 116                 memcpy(tmp->buffer + urlsize + 1, p, stsize);
 117                 p += stsize;
 118                 tmp->buffer[urlsize+1+stsize] = '\0';
 119                 devlist = tmp;
 120                 /* added for compatibility with recent versions of MiniSSDPd
 121                  * >= 2007/12/19 */
 122                 DECODELENGTH(usnsize, p);
 123                 p += usnsize;
 124                 if(p>buffer + sizeof(buffer))
 125                         break;
 126         }
 127         close(s);
 128         return devlist;
 129 }
 130