user/wsc_upnp/wsc_common.c

   1 #include <stdio.h>
   2 #include <stdarg.h>
   3 #include <stdlib.h>
   4 #include "wsc_common.h"
   5 #include "upnp.h"
   6
   7 static const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   8 static const char cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";
   9
  10
  11 extern int wsc_debug_level;
  12
  13 #ifdef RT_DEBUG
  14 void DBGPRINTF(int level, char *fmt, ...)
  15 {
  16         va_list ap;
  17
  18         va_start(ap, fmt);
  19         if (level <= wsc_debug_level)
  20         {
  21                 vprintf(fmt, ap);
  22         }
  23         va_end(ap);
  24 }
  25 #endif
  26
  27 void wsc_hexdump(char *title, char *ptr, int len)
  28 {
  29
  30         int32 i;
  31         char *tmp = ptr;
  32
  33         if (RT_DBG_PKT <= wsc_debug_level)
  34         {
  35                 printf("\n---StartOfMsgHexDump:%s\n", title);
  36                 for(i = 0; i < len; i++)
  37                 {
  38                         if(i%16==0 && i!=0)
  39                                 printf("\n");
  40                         printf("%02x ", tmp[i] & 0xff);
  41                 }
  42                 printf("\n---EndOfMsgHexDump!\n");
  43         }
  44
  45 }
  46
  47
  48
  49 void
  50 wsc_PrintEventType( IN Upnp_EventType S )
  51 {
  52     switch ( S ) {
  53
  54         case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
  55             printf( "UPNP_DISCOVERY_ADVERTISEMENT_ALIVE\n" );
  56             break;
  57         case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
  58             printf( "UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE\n" );
  59             break;
  60         case UPNP_DISCOVERY_SEARCH_RESULT:
  61             printf( "UPNP_DISCOVERY_SEARCH_RESULT\n" );
  62             break;
  63         case UPNP_DISCOVERY_SEARCH_TIMEOUT:
  64             printf( "UPNP_DISCOVERY_SEARCH_TIMEOUT\n" );
  65             break;
  66
  67             /*
  68                SOAP Stuff
  69              */
  70         case UPNP_CONTROL_ACTION_REQUEST:
  71             printf( "UPNP_CONTROL_ACTION_REQUEST\n" );
  72             break;
  73         case UPNP_CONTROL_ACTION_COMPLETE:
  74             printf( "UPNP_CONTROL_ACTION_COMPLETE\n" );
  75             break;
  76         case UPNP_CONTROL_GET_VAR_REQUEST:
  77             printf( "UPNP_CONTROL_GET_VAR_REQUEST\n" );
  78             break;
  79         case UPNP_CONTROL_GET_VAR_COMPLETE:
  80             printf( "UPNP_CONTROL_GET_VAR_COMPLETE\n" );
  81             break;
  82
  83             /*
  84                GENA Stuff
  85              */
  86         case UPNP_EVENT_SUBSCRIPTION_REQUEST:
  87             printf( "UPNP_EVENT_SUBSCRIPTION_REQUEST\n" );
  88             break;
  89         case UPNP_EVENT_RECEIVED:
  90             printf( "UPNP_EVENT_RECEIVED\n" );
  91             break;
  92         case UPNP_EVENT_RENEWAL_COMPLETE:
  93             printf( "UPNP_EVENT_RENEWAL_COMPLETE\n" );
  94             break;
  95         case UPNP_EVENT_SUBSCRIBE_COMPLETE:
  96             printf( "UPNP_EVENT_SUBSCRIBE_COMPLETE\n" );
  97             break;
  98         case UPNP_EVENT_UNSUBSCRIBE_COMPLETE:
  99             printf( "UPNP_EVENT_UNSUBSCRIBE_COMPLETE\n" );
 100             break;
 101
 102         case UPNP_EVENT_AUTORENEWAL_FAILED:
 103             printf( "UPNP_EVENT_AUTORENEWAL_FAILED\n" );
 104             break;
 105         case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
 106             printf( "UPNP_EVENT_SUBSCRIPTION_EXPIRED\n" );
 107             break;
 108
 109     }
 110 }
 111
 112 void wsc_printEvent(IN Upnp_EventType EventType,
 113                        IN void *Event)
 114 {
 115     printf( "\n\n\n======================================================================\n" );
 116     printf( "----------------------------------------------------------------------\n" );
 117     wsc_PrintEventType( EventType );
 118
 119     switch ( EventType ) {
 120
 121             /*
 122                SSDP
 123              */
 124         case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE:
 125         case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
 126         case UPNP_DISCOVERY_SEARCH_RESULT:
 127             {
 128                 struct Upnp_Discovery *d_event = ( struct Upnp_Discovery * )Event;
 129
 130                 printf( "ErrCode     =  %d\n", d_event->ErrCode );
 131                 printf( "Expires     =  %d\n", d_event->Expires );
 132                 printf( "DeviceId    =  %s\n", d_event->DeviceId );
 133                 printf( "DeviceType  =  %s\n", d_event->DeviceType );
 134                 printf( "ServiceType =  %s\n", d_event->ServiceType );
 135                 printf( "ServiceVer  =  %s\n", d_event->ServiceVer );
 136                 printf( "Location    =  %s\n", d_event->Location );
 137                 printf( "OS          =  %s\n", d_event->Os );
 138                 printf( "Ext         =  %s\n", d_event->Ext );
 139             }
 140             break;
 141
 142         case UPNP_DISCOVERY_SEARCH_TIMEOUT:
 143             // Nothing to print out here
 144             break;
 145
 146             /*
 147                SOAP
 148              */
 149         case UPNP_CONTROL_ACTION_REQUEST:
 150             {
 151                 struct Upnp_Action_Request *a_event = ( struct Upnp_Action_Request * )Event;
 152                 char *xmlbuff = NULL;
 153
 154                 printf( "ErrCode     =  %d\n", a_event->ErrCode );
 155                 printf( "ErrStr      =  %s\n", a_event->ErrStr );
 156                 printf( "ActionName  =  %s\n", a_event->ActionName );
 157                 printf( "UDN         =  %s\n", a_event->DevUDN );
 158                 printf( "ServiceID   =  %s\n", a_event->ServiceID );
 159                 if( a_event->ActionRequest ) {
 160                     xmlbuff = ixmlPrintDocument( a_event->ActionRequest );
 161                     if( xmlbuff )
 162                         printf( "ActRequest  =  %s\n", xmlbuff );
 163                     if( xmlbuff )
 164                         ixmlFreeDOMString( xmlbuff );
 165                     xmlbuff = NULL;
 166                 } else {
 167                     printf( "ActRequest  =  (null)\n" );
 168                 }
 169
 170                 if( a_event->ActionResult ) {
 171                     xmlbuff = ixmlPrintDocument( a_event->ActionResult );
 172                     if( xmlbuff )
 173                         printf( "ActResult   =  %s\n", xmlbuff );
 174                     if( xmlbuff )
 175                         ixmlFreeDOMString( xmlbuff );
 176                     xmlbuff = NULL;
 177                 } else {
 178                     printf( "ActResult   =  (null)\n" );
 179                 }
 180             }
 181             break;
 182
 183         case UPNP_CONTROL_ACTION_COMPLETE:
 184             {
 185                 struct Upnp_Action_Complete *a_event = ( struct Upnp_Action_Complete * )Event;
 186                 char *xmlbuff = NULL;
 187
 188                 printf( "ErrCode     =  %d\n", a_event->ErrCode );
 189                 printf( "CtrlUrl     =  %s\n", a_event->CtrlUrl );
 190                 if( a_event->ActionRequest ) {
 191                     xmlbuff = ixmlPrintDocument( a_event->ActionRequest );
 192                     if( xmlbuff )
 193                         printf( "ActRequest  =  %s\n", xmlbuff );
 194                     if( xmlbuff )
 195                         ixmlFreeDOMString( xmlbuff );
 196                     xmlbuff = NULL;
 197                 } else {
 198                     printf( "ActRequest  =  (null)\n" );
 199                 }
 200
 201                 if( a_event->ActionResult ) {
 202                     xmlbuff = ixmlPrintDocument( a_event->ActionResult );
 203                     if( xmlbuff )
 204                         printf( "ActResult   =  %s\n", xmlbuff );
 205                     if( xmlbuff )
 206                         ixmlFreeDOMString( xmlbuff );
 207                     xmlbuff = NULL;
 208                 } else {
 209                     printf( "ActResult   =  (null)\n" );
 210                 }
 211             }
 212             break;
 213
 214         case UPNP_CONTROL_GET_VAR_REQUEST:
 215             {
 216                 struct Upnp_State_Var_Request *sv_event = ( struct Upnp_State_Var_Request * )Event;
 217
 218                 printf( "ErrCode     =  %d\n", sv_event->ErrCode );
 219                 printf( "ErrStr      =  %s\n", sv_event->ErrStr );
 220                 printf( "UDN         =  %s\n", sv_event->DevUDN );
 221                 printf( "ServiceID   =  %s\n", sv_event->ServiceID );
 222                 printf( "StateVarName=  %s\n", sv_event->StateVarName );
 223                 printf( "CurrentVal  =  %s\n", sv_event->CurrentVal );
 224             }
 225             break;
 226
 227         case UPNP_CONTROL_GET_VAR_COMPLETE:
 228             {
 229                 struct Upnp_State_Var_Complete *sv_event =
 230                     ( struct Upnp_State_Var_Complete * )Event;
 231
 232                 printf( "ErrCode     =  %d\n", sv_event->ErrCode );
 233                 printf( "CtrlUrl     =  %s\n", sv_event->CtrlUrl );
 234                 printf( "StateVarName=  %s\n", sv_event->StateVarName );
 235                 printf( "CurrentVal  =  %s\n", sv_event->CurrentVal );
 236             }
 237             break;
 238
 239             /*
 240                GENA
 241              */
 242         case UPNP_EVENT_SUBSCRIPTION_REQUEST:
 243             {
 244                 struct Upnp_Subscription_Request *sr_event = ( struct Upnp_Subscription_Request * )Event;
 245
 246                 printf( "ServiceID   =  %s\n", sr_event->ServiceId );
 247                 printf( "UDN         =  %s\n", sr_event->UDN );
 248                 printf( "SID         =  %s\n", sr_event->Sid );
 249             }
 250             break;
 251
 252         case UPNP_EVENT_RECEIVED:
 253             {
 254                 struct Upnp_Event *e_event = ( struct Upnp_Event * )Event;
 255                 char *xmlbuff = NULL;
 256
 257                 printf( "SID         =  %s\n", e_event->Sid );
 258                 printf( "EventKey    =  %d\n", e_event->EventKey );
 259                 xmlbuff = ixmlPrintDocument( e_event->ChangedVariables );
 260                 printf( "ChangedVars =  %s\n", xmlbuff );
 261                 ixmlFreeDOMString( xmlbuff );
 262                 xmlbuff = NULL;
 263             }
 264             break;
 265
 266         case UPNP_EVENT_RENEWAL_COMPLETE:
 267             {
 268                 struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe *)Event;
 269
 270                 printf( "SID         =  %s\n", es_event->Sid);
 271                 printf( "ErrCode     =  %d\n", es_event->ErrCode);
 272                 printf( "TimeOut     =  %d\n", es_event->TimeOut);
 273             }
 274             break;
 275
 276         case UPNP_EVENT_SUBSCRIBE_COMPLETE:
 277         case UPNP_EVENT_UNSUBSCRIBE_COMPLETE:
 278             {
 279                 struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe *)Event;
 280
 281                 printf( "SID         =  %s\n", es_event->Sid );
 282                 printf( "ErrCode     =  %d\n", es_event->ErrCode );
 283                 printf( "PublisherURL=  %s\n", es_event->PublisherUrl );
 284                 printf( "TimeOut     =  %d\n", es_event->TimeOut );
 285             }
 286             break;
 287
 288         case UPNP_EVENT_AUTORENEWAL_FAILED:
 289         case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
 290             {
 291                 struct Upnp_Event_Subscribe *es_event = ( struct Upnp_Event_Subscribe * )Event;
 292
 293                 printf( "SID         =  %s\n", es_event->Sid );
 294                 printf( "ErrCode     =  %d\n", es_event->ErrCode );
 295                 printf( "PublisherURL=  %s\n", es_event->PublisherUrl );
 296                 printf( "TimeOut     =  %d\n", es_event->TimeOut );
 297             }
 298             break;
 299
 300     }
 301     printf( "----------------------------------------------------------------------\n" );
 302     printf( "======================================================================\n\n\n\n" );
 303
 304 }
 305
 306
 307 /* encode 3 8-bit binary bytes as 4 '6-bit' characters */
 308 void ILibencodeblock( unsigned char in[3], unsigned char out[4], int len )
 309 {
 310         out[0] = cb64[ in[0] >> 2 ];
 311         out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ];
 312         out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '=');
 313         out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '=');
 314 }
 315
 316 /*! \fn ILibBase64Encode(unsigned char* input, const int inputlen, unsigned char** output)
 317         \brief Base64 encode a stream adding padding and line breaks as per spec.
 318         \par
 319         \b Note: The encoded stream must be freed
 320         \param input The stream to encode
 321         \param inputlen The length of \a input
 322         \param output The encoded stream
 323         \returns The length of the encoded stream
 324 */
 325 int ILibBase64Encode(unsigned char* input, const int inputlen, unsigned char** output)
 326 {
 327         unsigned char* out;
 328         unsigned char* in;
 329
 330         *output = (unsigned char*)malloc(((inputlen * 4) / 3) + 5);
 331         out = *output;
 332         in  = input;
 333
 334         if (input == NULL || inputlen == 0)
 335         {
 336                 *output = NULL;
 337                 return 0;
 338         }
 339
 340         while ((in+3) <= (input+inputlen))
 341         {
 342                 ILibencodeblock(in, out, 3);
 343                 in += 3;
 344                 out += 4;
 345         }
 346         if ((input+inputlen)-in == 1)
 347         {
 348                 ILibencodeblock(in, out, 1);
 349                 out += 4;
 350         }
 351         else
 352         if ((input+inputlen)-in == 2)
 353         {
 354                 ILibencodeblock(in, out, 2);
 355                 out += 4;
 356         }
 357         *out = 0;
 358
 359         return (int)(out-*output);
 360 }
 361
 362 /* Decode 4 '6-bit' characters into 3 8-bit binary bytes */
 363 void ILibdecodeblock( unsigned char in[4], unsigned char out[3] )
 364 {
 365         out[ 0 ] = (unsigned char ) (in[0] << 2 | in[1] >> 4);
 366         out[ 1 ] = (unsigned char ) (in[1] << 4 | in[2] >> 2);
 367         out[ 2 ] = (unsigned char ) (((in[2] << 6) & 0xc0) | in[3]);
 368 }
 369
 370 /*! \fn ILibBase64Decode(unsigned char* input, const int inputlen, unsigned char** output)
 371         \brief Decode a base64 encoded stream discarding padding, line breaks and noise
 372         \par
 373         \b Note: The decoded stream must be freed
 374         \param input The stream to decode
 375         \param inputlen The length of \a input
 376         \param output The decoded stream
 377         \returns The length of the decoded stream
 378 */
 379 int ILibBase64Decode(unsigned char* input, const int inputlen, unsigned char** output)
 380 {
 381         unsigned char* inptr;
 382         unsigned char* out;
 383         unsigned char v;
 384         unsigned char in[4];
 385         int i, len;
 386
 387         if (input == NULL || inputlen == 0)
 388         {
 389                 *output = NULL;
 390                 return 0;
 391         }
 392
 393         *output = (unsigned char*)malloc(((inputlen * 3) / 4) + 4);
 394         out = *output;
 395         inptr = input;
 396
 397         while( inptr <= (input+inputlen) )
 398         {
 399                 for( len = 0, i = 0; i < 4 && inptr <= (input+inputlen); i++ )
 400                 {
 401                         v = 0;
 402                         while( inptr <= (input+inputlen) && v == 0 ) {
 403                                 v = (unsigned char) *inptr;
 404                                 inptr++;
 405                                 v = (unsigned char) ((v < 43 || v > 122) ? 0 : cd64[ v - 43 ]);
 406                                 if( v ) {
 407                                         v = (unsigned char) ((v == '$') ? 0 : v - 61);
 408                                 }
 409                         }
 410                         if( inptr <= (input+inputlen) ) {
 411                                 len++;
 412                                 if( v ) {
 413                                         in[ i ] = (unsigned char) (v - 1);
 414                                 }
 415                         }
 416                         else {
 417                                 in[i] = 0;
 418                         }
 419                 }
 420                 if( len )
 421                 {
 422                         ILibdecodeblock( in, out );
 423                         out += len-1;
 424                 }
 425         }
 426         *out = 0;
 427         return (int)(out-*output);
 428 }
 429