upnp_z256_ctrlpt.c

upnpsdk-1.0.4.tar.gz Intel UPnP SDK Source

	Upnp_Document DescDoc=NULL;
	int ret;

	if (d_event->ErrCode != UPNP_E_SUCCESS)
	    printf("Error in Discovery Callback -- %d\n", d_event->ErrCode);

	if ((ret=UpnpDownloadXmlDoc(d_event->Location, &DescDoc)) != UPNP_E_SUCCESS) {
	    printf("Error obtaining device description from %s -- error = %d\n", d_event->Location, ret );
	} else {
	    Z256CtrlPointAddDevice(DescDoc, d_event->Location, d_event->Expires);
	}

	if (DescDoc) UpnpDocument_free(DescDoc);

	Z256CtrlPointPrintList();
    }
    break;

    case UPNP_DISCOVERY_SEARCH_TIMEOUT:
	/* Nothing to do here... */
	break;

    case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE:
    {
	struct Upnp_Discovery *d_event = (struct Upnp_Discovery * ) Event;

	if (d_event->ErrCode != UPNP_E_SUCCESS)
	    printf("Error in Discovery ByeBye Callback -- %d\n", d_event->ErrCode);

	printf("Received ByeBye for Device: %s\n", d_event->DeviceId);
	Z256CtrlPointRemoveDevice(d_event->DeviceId);

	printf("After byebye:\n");
	Z256CtrlPointPrintList();

    }
    break;

    /* SOAP Stuff */
    case UPNP_CONTROL_ACTION_COMPLETE:
    {
	struct Upnp_Action_Complete *a_event = (struct Upnp_Action_Complete * ) Event;

	if (a_event->ErrCode != UPNP_E_SUCCESS)
	    printf("Error in  Action Complete Callback -- %d\n", a_event->ErrCode);

	/* No need for any processing here, just print out results.  Service state
	   table updates are handled by events. */
    }
    break;
      
    case UPNP_CONTROL_GET_VAR_COMPLETE:
    {
	struct Upnp_State_Var_Complete *sv_event = (struct Upnp_State_Var_Complete * ) Event;

	if (sv_event->ErrCode != UPNP_E_SUCCESS)
	    printf("Error in Get Var Complete Callback -- %d\n", sv_event->ErrCode);

    }
    break;
      
    /* GENA Stuff */
    case UPNP_EVENT_RECEIVED:
    {
	struct Upnp_Event *e_event = (struct Upnp_Event * ) Event;

	Z256CtrlPointHandleEvent(e_event->Sid, e_event->EventKey, e_event->ChangedVariables);

    }
    break;

    case UPNP_EVENT_SUBSCRIBE_COMPLETE:
    case UPNP_EVENT_UNSUBSCRIBE_COMPLETE:
    case UPNP_EVENT_RENEWAL_COMPLETE:
    {
	struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe * ) Event;

	if (es_event->ErrCode != UPNP_E_SUCCESS)
	    printf("Error in Event Subscribe Callback -- %d\n", es_event->ErrCode);
	else
	    Z256CtrlPointHandleSubscribeUpdate(es_event->PublisherUrl, es_event->Sid, es_event->TimeOut);
    }
    break;

    case UPNP_EVENT_AUTORENEWAL_FAILED:
    case UPNP_EVENT_SUBSCRIPTION_EXPIRED:
    {
	int TimeOut=default_timeout;
	Upnp_SID newSID;
	int ret;
	struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe * ) Event;

	ret=UpnpSubscribe(ctrlpt_handle, es_event->PublisherUrl,
			  &TimeOut, newSID);
	if (ret==UPNP_E_SUCCESS) {
	    printf("Subscribed to EventURL with SID=%s\n", newSID);
	    Z256CtrlPointHandleSubscribeUpdate(es_event->PublisherUrl, newSID, TimeOut);
	} else {
	    printf("Error Subscribing to EventURL -- %d\n", ret);
	}
    }
    break;


    /* ignore these cases, since this is not a device */
    case UPNP_EVENT_SUBSCRIPTION_REQUEST:
    case UPNP_CONTROL_GET_VAR_REQUEST:
    case UPNP_CONTROL_ACTION_REQUEST:
	break;


    }

    return(0);
}



/********************************************************************************
 * Z256CtrlPointVerifyTimeouts
 *
 * Description: 
 *       Checks the advertisement and subscription timeouts for each device
 *       and service in the global device list.  If an advertisement expires,
 *       the device is removed from the list.  If an advertisement is about to
 *       expire, a search request is sent for that device.  If a subscription
 *       expires, request a new one.  If a subscription is about to expire,
 *       try to renew it.
 *
 * Parameters:
 *    incr -- The increment to subtract from the timeouts each time the
 *            function is called.
 *
 ********************************************************************************/
void Z256CtrlPointVerifyTimeouts(int incr)
{
    struct Z256DeviceNode *prevdevnode, *curdevnode;
    int ret;

    pthread_mutex_lock(&DeviceListMutex);

    prevdevnode = curdevnode = GlobalDeviceList;
    while (curdevnode) {
	curdevnode->device.AdvrTimeOut -= incr;
	//printf("Advertisement Timeout: %d\n", curdevnode->device.AdvrTimeOut);
	
	if (curdevnode->device.AdvrTimeOut <= 0) {
	    /* This advertisement has expired, so we should remove the device
	       from the list */
	    if (GlobalDeviceList == curdevnode) 
		GlobalDeviceList = curdevnode->next;
	    prevdevnode->next = curdevnode->next;
	    Z256CtrlPointDeleteNode(curdevnode);
	} else {
	    
	    if (curdevnode->device.AdvrTimeOut < 2*incr) {
		/* This advertisement is about to expire, so send
		   out a search request for this device UDN to 
		   try to renew */
		ret = UpnpSearchAsync(ctrlpt_handle, incr, curdevnode->device.UDN, NULL);
		if (ret != UPNP_E_SUCCESS)
		    printf("Error sending search request for Device UDN: %s -- err = %d\n", curdevnode->device.UDN, ret);
		
	    }

	    prevdevnode = curdevnode;

	}	
	
	curdevnode = curdevnode->next;

    }
    pthread_mutex_unlock(&DeviceListMutex);

}








/********************************************************************************
 * Z256CtrlPointPrintCommands
 *
 * Description: 
 *       Print the list of valid command line commands to the user
 *
 * Parameters:
 *   None
 *
 ********************************************************************************/
void Z256CtrlPointPrintCommands() 
{
    int i;
    int numofcmds=sizeof(cmdloop_cmdlist)/sizeof(cmdloop_commands);

    printf("\nValid Commands:\n");
    for (i=0; i<numofcmds; i++) {
	printf("  %-14s %s\n", cmdloop_cmdlist[i].str, cmdloop_cmdlist[i].args);
    }
    printf("\n");
}






/********************************************************************************
 * Z256CtrlPointCommandLoop
 *
 * Description: 
 *       Function that receives commands from the user at the command prompt
 *       during the lifetime of the control point, and calls the appropriate
 *       functions for those commands.
 *
 * Parameters:
 *    None
 *
 ********************************************************************************/
void* Z256CtrlPointCommandLoop(void *args)
{
    int stoploop=0;
    char cmdline[100];
    char cmd[100];
    char strarg[100];
    int arg1;
    int arg2;
    int cmdnum=-1;
    int numofcmds=sizeof(cmdloop_cmdlist)/sizeof(cmdloop_commands);
    int cmdfound=0;
    int i;
    int invalid_args;
    int arg_val_err=-99999;


    while (!stoploop) {
	cmdfound=0;
	sprintf(cmdline, " ");
	sprintf(cmd, " ");
	arg1 = arg_val_err;
	arg2 = arg_val_err;
	invalid_args=0;

	printf("\n>> ");

	// Get a command line
	fgets(cmdline, 100, stdin);

	/* Get the command name (first string of command line).
	   Also, assume two integer arguments and parse those. */
	sscanf(cmdline, "%s %d %d", cmd, &arg1, &arg2);

	for(i = 0; i < numofcmds; i++) {
	    if (strcasecmp(cmd, cmdloop_cmdlist[i].str) == 0) {
		cmdnum = cmdloop_cmdlist[i].cmdnum;
		cmdfound = 1;
		break;
	    }
	}

	if (cmdfound) {
	    switch(cmdnum) {
	    case PRTHELP:
		Z256CtrlPointPrintHelp();
		break;
	    case POW_ON:
		if (arg1 == arg_val_err)
		    invalid_args = 1;
		else
		    Z256CtrlPointSendAction(Z256_SERVICE_CONTROL, arg1, "Power_On", NULL, NULL, 0);
		break;
	    case POW_OFF:
		if (arg1 == arg_val_err)
		    invalid_args = 1;
		else
		    Z256CtrlPointSendAction(Z256_SERVICE_CONTROL, arg1, "Power_Off", NULL, NULL, 0);
		break;
	    case POWON:
                if (arg1 == arg_val_err)
                    invalid_args = 1;
                else
                    Z256CtrlPointSendAction(Z256_SERVICE_CONTROL, arg1, "PowerOn", NULL, NULL, 0);
                break;
            case POWOFF:
                if (arg1 == arg_val_err)
                    invalid_args = 1;
                else
                    Z256CtrlPointSendAction(Z256_SERVICE_CONTROL, arg1, "PowerOff", NULL, NULL, 0);
                break;
	    case CTRLACTION:
		/* re-parse commandline since second arg is string */
		sscanf(cmdline, "%s %d %s", cmd, &arg1, strarg);
		if (arg1 == arg_val_err)
		    invalid_args = 1;
		else
		    Z256CtrlPointSendAction(Z256_SERVICE_CONTROL, arg1, strarg, NULL, NULL, 0);
		break;
	    case CTRLGETVAR:
		/* re-parse commandline since second arg is string */
		sscanf(cmdline, "%s %d %s", cmd, &arg1, strarg);
		if (arg1 == arg_val_err)
		    invalid_args = 1;
		else
		    Z256CtrlPointGetVar(Z256_SERVICE_CONTROL, arg1, strarg);
		break;
	    case PRTDEV:
		if (arg1 == arg_val_err)
		    invalid_args = 1;
		else
		    Z256CtrlPointPrintDevice(arg1);
		break;
	    case LSTDEV:
		Z256CtrlPointPrintList();
		break;
	    case REFRESH:
		Z256CtrlPointRefresh();
		break;
	    case EXITCMD:
		printf("Shutting down...\n");
		UpnpUnRegisterClient(ctrlpt_handle);
		UpnpFinish();
		exit(0);
		break;
	    default:
		printf("command not yet implemented: %s\n", cmd);
		Z256CtrlPointPrintCommands();
	    }

	    if (invalid_args) {
		printf("Invalid args in command: %s\n", cmd);
		Z256CtrlPointPrintCommands();
	    }
	} else {
	    printf("Unknown command: %s\n", cmd);
	    Z256CtrlPointPrintCommands();
	}

    }

    return(NULL);
}



/********************************************************************************
 * Z256CtrlPointTimerLoop
 *
 * Description: 
 *       Function that runs in its own thread and monitors advertisement
 *       and subscription timeouts for devices in the global device list.
 *
 * Parameters:
 *    None
 *
 ********************************************************************************/
void* Z256CtrlPointTimerLoop(void *args)
{

    int incr = 30; // how often to verify the timeouts

    while (1) {
	sleep(incr);
	Z256CtrlPointVerifyTimeouts(incr);
    }
    
}





int main(int argc, char** argv)
{

    int ret=1;
    pthread_t timer_thread, cmdloop_thread;
    int code;
    int port;
    char *ip_address;
    int sig;
    sigset_t sigs_to_catch;

    if (argc!=3) {
	printf("wrong number of arguments\n Usage: %s ipaddress port\n", argv[0]);
	printf("\tipaddress:     IP address of the device (must match desc. doc)\n");
	printf("\t\te.g.: 192.168.0.2\n");
	printf("\tport:          Port number to use for receiving UPnP messages (must match desc. doc)\n");
	printf("\t\te.g.: 5432\n");
	exit(1);
    }

    ip_address=argv[1];  
    sscanf(argv[2],"%d",&port);


/* ######################## UpnpInit(ip_address, port) ##################### */

    printf("Intializing UPnP \n\twith ipaddress=%s port=%d \n", ip_address, port);
    if ((ret = UpnpInit(ip_address, port))) {
	printf("Error with UpnpInit -- %d\n", ret);
	UpnpFinish();
	exit(1);
    }
   
    printf("UPnP Initialized\n");

/* ######################################################################### */

/* ######################## UpnpRegisterClient() ########################### */

    printf("Registering the Control Point\n");
    if ((ret = UpnpRegisterClient(Z256CtrlPointCallbackEventHandler, &ctrlpt_handle, &ctrlpt_handle)))
    {
	printf("Error registering control point : %d\n", ret);
	UpnpFinish();
	exit(1);
    }
    printf("Control Point Registered\n");

/* ######################################################################### */

    Z256CtrlPointRefresh();

    // start a command loop thread
    code = pthread_create( &cmdloop_thread, NULL, Z256CtrlPointCommandLoop,
			   NULL );

    // start a timer thread
    code = pthread_create( &timer_thread, NULL, Z256CtrlPointTimerLoop,
			   NULL );


    /* Catch Ctrl-C and properly shutdown */
    sigemptyset(&sigs_to_catch);
    sigaddset(&sigs_to_catch, SIGINT);
    sigwait(&sigs_to_catch, &sig);
    printf("Shutting down on signal %d...\n", sig);
    UpnpUnRegisterClient(ctrlpt_handle);
    UpnpFinish();

    exit(0);
}