upnpapi.c

upnpsdk-1.0.4.tar.gz Intel UPnP SDK Source

    OUT char* descURL,
    OUT char* descAlias )
{
    int retVal;
    char *membuf = NULL;
    char *descStr = NULL;
    char *actualAliasStr = NULL;
    int descIsMalloked = 0;

    if ( description == NULL )
    {
        return UPNP_E_INVALID_PARAM;
    }

    // non-URL description must have configuration specified
    if ( descriptionType != UPNPREG_URL_DESC && (!config_baseURL) )
    {
        return UPNP_E_INVALID_PARAM;
    }

    if ( descriptionType == UPNPREG_URL_DESC )
    {
        if ((retVal=UpnpDownloadXmlDoc(description, xmlDoc))!=UPNP_E_SUCCESS)
        {
            return retVal;
        }
    }
    else if ( descriptionType == UPNPREG_FILENAME_DESC )
    {
        FILE *fp;
        unsigned fileLen;
        unsigned num_read;

        if ( (fp = fopen(description, "rb")) == NULL )
        {
            return UPNP_E_FILE_NOT_FOUND;
        }
        fseek( fp, 0, SEEK_END );
        fileLen = ftell( fp );
        rewind( fp );

        if ( (membuf = (char *)malloc(fileLen + 1)) == NULL )
        {
            fclose( fp );
            return UPNP_E_OUTOF_MEMORY;
        }

        num_read = fread( membuf, 1, fileLen, fp );
        if ( num_read != fileLen )
        {
            fclose( fp );
            free( membuf );
            return UPNP_E_FILE_READ_ERROR;
        }

        membuf[fileLen] = 0;
        fclose( fp );
        *xmlDoc = UpnpParse_Buffer( membuf );
        free( membuf );
    }
    else if ( descriptionType == UPNPREG_BUF_DESC )
    {
        *xmlDoc = UpnpParse_Buffer( description );
    }
    else
    {
        return UPNP_E_INVALID_PARAM;
    }

    if ( *xmlDoc == NULL )
    {
        return UPNP_E_INVALID_DESC;
    }

    // determine alias
    if ( config_baseURL )
    {
        char *aliasStr;
        struct sockaddr_in serverAddr;

        if ( descriptionType == UPNPREG_BUF_DESC )
        {
            aliasStr = "description.xml";
        }
        else  // URL or filename
        {
            retVal = GetNameForAlias( description, &aliasStr );
            if ( retVal != UPNP_E_SUCCESS )
            {
                UpnpDocument_free( *xmlDoc );
                return retVal;
            }
        }

        get_server_addr( &serverAddr );

        // config
        retVal = Configure_Urlbase( *xmlDoc, &serverAddr,
            aliasStr, &actualAliasStr, &descStr );
        if ( retVal != UPNP_E_SUCCESS )
        {
            UpnpDocument_free( *xmlDoc );
            return retVal;
        }
        descIsMalloked = 1;
    }
    else // manual
    {
        descStr = description;
    }

    if ( strlen(descStr) > (LINE_SIZE - 1) )
    {
        UpnpDocument_free( *xmlDoc );
        if ( descIsMalloked )
        {
            free( descStr );
            free( actualAliasStr );
        }
        return UPNP_E_URL_TOO_BIG;
    }

    strcpy( descURL, descStr );

    if ( descIsMalloked )
    {
        strcpy( descAlias, actualAliasStr );
        free( descStr );
        free( actualAliasStr );
    }

    assert( *xmlDoc != NULL );

    return UPNP_E_SUCCESS;
}

#else   // no web server

// returns:
//   UPNP_E_SUCCESS
//   UPNP_E_NO_WEB_SERVER
//   UPNP_E_INVALID_PARAM
//   UPNP_E_URL_TOO_LONG
static int GetDescDocumentAndURL( IN Upnp_DescType descriptionType,
    IN char* description,
    IN unsigned int bufferLen,
    IN int config_baseURL,
    OUT Upnp_Document* xmlDoc,
    OUT char* descURL,
    OUT char* descAlias )
{
    int retVal;

    if ( (descriptionType != UPNPREG_URL_DESC) || config_baseURL )
    {
        return UPNP_E_NO_WEB_SERVER;
    }

    if ( description == NULL )
    {
        return UPNP_E_INVALID_PARAM;
    }

    if ( strlen(description) > (LINE_SIZE - 1) )
    {
        return UPNP_E_URL_TOO_BIG;
    }
    strcpy( descURL, description );

    if ((retVal=UpnpDownloadXmlDoc(description, xmlDoc))!=UPNP_E_SUCCESS)
    {
        return retVal;
    }

    return UPNP_E_SUCCESS;
}


#endif // INTERNAL_WEB_SERVER
// ********************************************************

// return codes:
//   UPNP_E_SUCCESS
//   UPNP_E_OUTOF_MEMORY
//   UPNP_E_URL_TOO_BIG
//   UPNP_E_INVALID_PARAM
//   UPNP_E_FILE_NOT_FOUND
//   UPNP_E_FILE_READ_ERROR
//   UPNP_E_INVALID_URL
//   UPNP_E_INVALID_DESC
//   UPNP_E_EXT_NOT_XML
//   UPNP_E_NETWORK_ERROR
//   UPNP_E_SOCKET_WRITE
//   UPNP_E_SOCKET_READ
//   UPNP_E_SOCKET_BIND
//   UPNP_E_SOCKET_CONNECT
//   UPNP_E_OUTOF_SOCKET
//   UPNP_E_NO_WEB_SERVER
int UpnpRegisterRootDevice2( IN Upnp_DescType descriptionType,
        IN const char* description_const,
        IN size_t bufferLen,    // ignored unless descType == UPNPREG_BUF_DESC
        IN int config_baseURL,
        IN Upnp_FunPtr Fun,
        IN const void* Cookie,
        OUT UpnpDevice_Handle* Hnd )
{
    struct Handle_Info * HInfo;
    int retVal=0;
    char *description = (char *)description_const;

    DBGONLY(UpnpPrintf(UPNP_INFO,API,__FILE__,__LINE__,"Inside UpnpRegisterRootDevice2 \n");)

    if(UpnpSdkInit != 1)
    {
        return UPNP_E_FINISH;
    }
    if ( Hnd == NULL || Fun == NULL )
    {
        return UPNP_E_INVALID_PARAM;
    }

    HandleLock();
    if ((*Hnd = GetFreeHandle()) == UPNP_E_OUTOF_HANDLE)
    {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY;
    }

    HInfo = (struct Handle_Info *) malloc (sizeof(struct Handle_Info));
    if (HInfo == NULL)
    {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY;
    }
    HandleTable[*Hnd] = HInfo;

    // prevent accidental removal of a non-existent alias
    HInfo->aliasInstalled = 0;

    retVal = GetDescDocumentAndURL( descriptionType, description,
        bufferLen, config_baseURL, &HInfo->DescDocument,
        HInfo->DescURL, HInfo->DescAlias );

    if ( retVal != UPNP_E_SUCCESS )
    {
        FreeHandle(*Hnd);
        HandleUnlock();
        return retVal;
    }

    HInfo->aliasInstalled = (config_baseURL != 0);

    HInfo->HType = HND_DEVICE;
    HInfo->Callback = Fun;
    HInfo->Cookie = (void *)Cookie;
    HInfo->MaxAge = DEFAULT_MAXAGE;
    HInfo->DeviceList = NULL;
    HInfo->ServiceList = NULL;
    CLIENTONLY(HInfo->ClientSubList=NULL;)
    HInfo->MaxSubscriptions=UPNP_INFINITE;
    HInfo->MaxSubscriptionTimeOut=UPNP_INFINITE;


    DBGONLY(
    UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: Valid Description\n");
    UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: DescURL : %s\n", HInfo->DescURL);)

    HInfo->DeviceList  = UpnpDocument_getElementsByTagName(HInfo->DescDocument, "device");

    if (HInfo->DeviceList == NULL)
    {
        FreeHandle(*Hnd);
        HandleUnlock();

        DBGONLY(UpnpPrintf(UPNP_INFO,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: No devices found for RootDevice\n");)

        return UPNP_E_INVALID_DESC;
    }

    HInfo->ServiceList = UpnpDocument_getElementsByTagName(HInfo->DescDocument , "serviceList");

    if (HInfo->ServiceList == NULL)
    {
        FreeHandle(*Hnd);
        HandleUnlock();

        DBGONLY(UpnpPrintf(UPNP_INFO,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: No services found for RootDevice\n");)

        return UPNP_E_INVALID_DESC;
    }

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: Gena Check\n");)

    //*******************************
    //GENA SET UP
    //*******************************

    if (getServiceTable(HInfo->DescDocument, &HInfo->ServiceTable,HInfo->DescURL))
    {

       DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"UpnpRegisterRootDevice2: GENA Service Table \n");)

    }
    else
    {
       DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"\nUpnpRegisterRootDevice2: No Eventing Support Found \n");)
    }
    HandleUnlock();


    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Exiting RegisterRootDevice2 Successfully\n");)

    return UPNP_E_SUCCESS;
}  /****************** End of UpnpRegisterRootDevice2  *********************/


#endif //INCLUDE_DEVICE_APIS

#ifdef INCLUDE_CLIENT_APIS
int UpnpRegisterClient(IN Upnp_FunPtr Fun,
                IN const void * Cookie,
                OUT UpnpClient_Handle *Hnd)
{
    struct Handle_Info * HInfo;

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Inside UpnpRegisterClient \n");)

    if(UpnpSdkInit != 1)
    {
        HandleUnlock();
        return UPNP_E_FINISH;
    }
    if (Fun == NULL || Hnd == NULL) 
        return UPNP_E_INVALID_PARAM;

    HandleLock();
    if ((*Hnd = GetFreeHandle()) == UPNP_E_OUTOF_HANDLE) 
    {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY; 
    }
    HInfo = (struct Handle_Info *) malloc (sizeof(struct Handle_Info));
    if (HInfo == NULL) 
    {
        HandleUnlock();
        return UPNP_E_OUTOF_MEMORY;
    }

    HInfo->HType = HND_CLIENT;
    HInfo->Callback = Fun;
    HInfo->Cookie = (void *) Cookie;
    HInfo->MaxAge = 0;
    HInfo->ClientSubList=NULL;
    DEVICEONLY(HInfo->MaxSubscriptions=UPNP_INFINITE;)
    DEVICEONLY(HInfo->MaxSubscriptionTimeOut=UPNP_INFINITE;)
    
    HandleTable[*Hnd] = HInfo;

    HandleUnlock();

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Exiting UpnpRegisterClient \n");
)

    return  UPNP_E_SUCCESS;
}  /****************** End of UpnpRegisterClient   *********************/
#endif // INCLUDE_CLIENT_APIS

#ifdef INCLUDE_CLIENT_APIS
int UpnpUnRegisterClient(IN UpnpClient_Handle Hnd)
{
    struct Handle_Info *HInfo;

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Inside UpnpUnRegisterClient \n");)
    #if EXCLUDE_GENA == 0
    if (genaUnregisterClient(Hnd) != UPNP_E_SUCCESS)
        return UPNP_E_INVALID_HANDLE;
    #endif
    HandleLock();
    if (GetHandleInfo(Hnd, &HInfo) == UPNP_E_INVALID_HANDLE)
    {
       HandleUnlock();
       return UPNP_E_INVALID_HANDLE;
    }     
    FreeHandle(Hnd);
    HandleUnlock();

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Exiting UpnpUnRegisterClient \n");)

    return  UPNP_E_SUCCESS;
}  /****************** End of UpnpUnRegisterClient *********************/
#endif // INCLUDE_CLIENT_APIS

//-----------------------------------------------------------------------------
//
//                                   SSDP interface
//
//-----------------------------------------------------------------------------

#ifdef INCLUDE_DEVICE_APIS
#if EXCLUDE_SSDP == 0

int UpnpSendAdvertisement(IN UpnpDevice_Handle Hnd, IN int Exp)
{
    struct Handle_Info *  SInfo=NULL; 
    int retVal = 0, *ptrMx;
    upnp_timeout *adEvent;

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Inside UpnpSendAdvertisement \n");)

    HandleLock();
    if(GetHandleInfo(Hnd, &SInfo) != HND_DEVICE)
    {
        HandleUnlock();
        return UPNP_E_INVALID_HANDLE;
    }
    if (Exp < 1)
	   Exp = DEFAULT_MAXAGE;
    SInfo->MaxAge = Exp; 
    HandleUnlock(); 
    retVal = AdvertiseAndReply(1, Hnd, 0, (struct sockaddr_in *) NULL, 
                             (char *) NULL, (char *) NULL, (char *) NULL, 
                             Exp);
    
    if (retVal != UPNP_E_SUCCESS)
        return retVal;
    ptrMx = (int *) malloc (sizeof(int));
    if (ptrMx == NULL)
        return UPNP_E_OUTOF_MEMORY;
    adEvent = (upnp_timeout *) malloc (sizeof(upnp_timeout));
    
    if (adEvent == NULL)
    {   
        free(ptrMx); 
        return UPNP_E_OUTOF_MEMORY;
    }
    *ptrMx = Exp;
    adEvent->handle = Hnd;
    adEvent->Event = ptrMx;
    
    if ((retVal = ScheduleTimerEvent(Exp - AUTO_ADVERTISEMENT_TIME, 
                  AutoAdvertise, adEvent, &GLOBAL_TIMER_THREAD, 
                  &(adEvent->eventId))) !=UPNP_E_SUCCESS)
    {
        free(adEvent);
        free(ptrMx);
        return retVal;
    }   

    DBGONLY(UpnpPrintf(UPNP_ALL,API,__FILE__,__LINE__,"Exiting UpnpSendAdvertisement \n");
)

    return retVal;