/********************************************************************************
* upnp_igd_start
*
* Description:
* Start uPnP IGD context.
*
* Parameters:
* igd_ctxt -- The upnp igd context
*
********************************************************************************/
int upnp_igd_start(upnp_igd_context*igd_ctxt) {
int ret;
ithread_mutex_lock(&igd_ctxt->mutex);
if(igd_ctxt->upnp_handle != -1) {
upnp_igd_print(igd_ctxt, UPNP_IGD_WARNING, "uPnP IGD client already started...");
ithread_mutex_unlock(&igd_ctxt->mutex);
return -1;
}
upnp_igd_print(igd_ctxt, UPNP_IGD_DEBUG, "uPnP IGD client registering...");
ret = UpnpRegisterClient(upnp_igd_callback, igd_ctxt, &igd_ctxt->upnp_handle);
if (ret != UPNP_E_SUCCESS) {
upnp_igd_print(igd_ctxt, UPNP_IGD_ERROR, "Error registering IGD client: %d", ret);
ithread_mutex_unlock(&igd_ctxt->mutex);
return ret;
}
upnp_igd_print(igd_ctxt, UPNP_IGD_MESSAGE, "uPnP IGD client registered");
/* Initialize timer stuff */
ithread_create(&igd_ctxt->timer_thread, NULL, upnp_igd_timer_loop, igd_ctxt);
ithread_mutex_unlock(&igd_ctxt->mutex);
ret = upnp_igd_refresh(igd_ctxt);
return ret;
}
bool UPnP::init()
{
int res;
if((res = UpnpInit(0, 0)) != UPNP_E_SUCCESS)
{
Log::err("UpnpInit error: %s",UpnpGetErrorMessage(res));
return false;
}
if((res = UpnpRegisterClient(Callback, this, &CtrlPnt)) != UPNP_E_SUCCESS)
{
Log::err("UpnpRegisterClient error: %s",UpnpGetErrorMessage(res));
return false;
}
deviceList = new DeviceList();
cfg = new Config("config.xml", &deviceList, CtrlPnt);
if((res = UpnpSetMaxContentLength(atoi(cfg->UpnpMaxContentLength.c_str()))) != UPNP_E_SUCCESS)
{
Log::err("UpnpSetMaxContentLength error: %s",UpnpGetErrorMessage(res));
return false;
}
isInited = true;
return isInited;
}
UpnpInstanceWrapper *UpnpInstanceWrapper::get(vlc_object_t *p_obj, Upnp_FunPtr callback, SD::MediaServerList *opaque)
{
vlc_mutex_locker lock( &s_lock );
if ( s_instance == NULL )
{
UpnpInstanceWrapper* instance = new(std::nothrow) UpnpInstanceWrapper;
if ( unlikely( !instance ) )
return NULL;
#ifdef UPNP_ENABLE_IPV6
char* psz_miface = var_InheritString( p_obj, "miface" );
msg_Info( p_obj, "Initializing libupnp on '%s' interface", psz_miface );
int i_res = UpnpInit2( psz_miface, 0 );
free( psz_miface );
#else
/* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */
int i_res = UpnpInit( 0, 0 );
#endif
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
ixmlRelaxParser( 1 );
/* Register a control point */
i_res = UpnpRegisterClient( Callback, instance, &instance->handle_ );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
delete instance;
return NULL;
}
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
msg_Err( p_obj, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
delete instance;
return NULL;
}
s_instance = instance;
}
s_instance->refcount_++;
// This assumes a single UPNP SD instance
if (callback && opaque)
{
assert(!s_instance->callback_ && !s_instance->opaque_);
s_instance->opaque_ = opaque;
s_instance->callback_ = callback;
}
return s_instance;
}
/*
* Initializes UPNP instance.
*/
static int Open( vlc_object_t *p_this )
{
int i_res;
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = ( services_discovery_sys_t * )
calloc( 1, sizeof( services_discovery_sys_t ) );
if( !( p_sd->p_sys = p_sys ) )
return VLC_ENOMEM;
/* Initialize on first IPv4-capable adapter and first open port
* TODO: use UpnpInit2() to utilize IPv6.
*/
i_res = UpnpInit( 0, 0 );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
free( p_sys );
return VLC_EGENERIC;
}
p_sys->p_server_list = new MediaServerList( p_sd );
vlc_mutex_init( &p_sys->callback_lock );
/* Register a control point */
i_res = UpnpRegisterClient( Callback, p_sd, &p_sys->client_handle );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* Search for media servers */
i_res = UpnpSearchAsync( p_sys->client_handle, 5,
MEDIA_SERVER_DEVICE_TYPE, p_sd );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Error sending search request: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/********************************************************************************
* TvCtrlPointStart
*
* Description:
* Call this function to initialize the UPnP library and start the TV Control
* Point. This function creates a timer thread and provides a callback
* handler to process any UPnP events that are received.
*
* Parameters:
* None
*
* Returns:
* TV_SUCCESS if everything went well, else TV_ERROR
*
********************************************************************************/
int
TvCtrlPointStart( print_string printFunctionPtr,
state_update updateFunctionPtr )
{
ithread_t timer_thread;
int rc;
unsigned short port = 0;
char *ip_address = NULL;
SampleUtil_Initialize( printFunctionPtr );
SampleUtil_RegisterUpdateFunction( updateFunctionPtr );
ithread_mutex_init( &DeviceListMutex, 0 );
SampleUtil_Print(
"Initializing UPnP Sdk with\n"
"\tipaddress = %s port = %u\n",
ip_address, port );
rc = UpnpInit( ip_address, port );
if( UPNP_E_SUCCESS != rc ) {
SampleUtil_Print( "WinCEStart: UpnpInit() Error: %d", rc );
UpnpFinish();
return TV_ERROR;
}
if( NULL == ip_address ) {
ip_address = UpnpGetServerIpAddress();
}
if( 0 == port ) {
port = UpnpGetServerPort();
}
SampleUtil_Print(
"UPnP Initialized\n"
"\tipaddress= %s port = %u\n",
ip_address, port );
SampleUtil_Print( "Registering Control Point" );
rc = UpnpRegisterClient( TvCtrlPointCallbackEventHandler,
&ctrlpt_handle, &ctrlpt_handle );
if( UPNP_E_SUCCESS != rc ) {
SampleUtil_Print( "Error registering CP: %d", rc );
UpnpFinish();
return TV_ERROR;
}
SampleUtil_Print( "Control Point Registered" );
TvCtrlPointRefresh();
// start a timer thread
ithread_create( &timer_thread, NULL, TvCtrlPointTimerLoop, NULL );
return TV_SUCCESS;
}
int CtrlPointStart()
{
//ithread_t timer_thread;
int rc;
unsigned short port = 0;
char *ip_address = NULL;
ithread_mutex_init(&DeviceListMutex, 0);
g_print("Initializing UPnP Sdk with\n"
"\tipaddress = %s port = %u\n",
ip_address ? ip_address : "{NULL}", port);
rc = UpnpInit(ip_address, port);
if (rc != UPNP_E_SUCCESS) {
g_print("WinCEStart: UpnpInit() Error: %d\n", rc);
UpnpFinish();
return CP_ERROR;
}
if (!ip_address) {
ip_address = UpnpGetServerIpAddress();
}
if (!port) {
port = UpnpGetServerPort();
}
g_print("UPnP Initialized\n"
"\tipaddress = %s port = %u\n",
ip_address ? ip_address : "{NULL}", port);
g_print("Registering Control Point\n");
rc = UpnpRegisterClient(CtrlPointCallbackEventHandler,
&ctrlpt_handle, &ctrlpt_handle);
if (rc != UPNP_E_SUCCESS) {
g_print("Error registering CP: %d\n", rc);
UpnpFinish();
return CP_ERROR;
}
g_print("Control Point Registered\n");
CtrlPointRefresh();
/* start a timer thread */
//ithread_create(&timer_thread, NULL, TvCtrlPointTimerLoop, NULL);
//ithread_detach(timer_thread);
return CP_SUCCESS;
}
static int Open( vlc_object_t *p_this )
{
int res;
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = ( services_discovery_sys_t * )
calloc( 1, sizeof( services_discovery_sys_t ) );
if(!(p_sd->p_sys = p_sys))
return VLC_ENOMEM;
res = UpnpInit( 0, 0 );
if( res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
free( p_sys );
return VLC_EGENERIC;
}
p_sys->serverList = new MediaServerList( p_sd );
vlc_mutex_init( &p_sys->callbackLock );
res = UpnpRegisterClient( Callback, p_sd, &p_sys->clientHandle );
if( res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
res = UpnpSearchAsync( p_sys->clientHandle, 5,
MEDIA_SERVER_DEVICE_TYPE, p_sd );
if( res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "%s", UpnpGetErrorMessage( res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
/******************************************************************************
* WscUPnPCPStart
*
* Description:
* Registers the UPnP Control Point, and sends out M-SEARCH.
*
* Parameters:
*
* char *ipAddr - ip address to initialize the Control Point Service.
* unsigned short port - port number to initialize the control Point Service.
*
* Return:
* success - WSC_SYS_SUCCESS
* failed - WSC_SYS_ERROR
*****************************************************************************/
int WscUPnPCPStart(
IN char *ipAddr,
IN unsigned short port)
{
int rc;
DBGPRINTF(RT_DBG_INFO, "Registering Control Point...\n");
rc = UpnpRegisterClient(WscUPnPCPDeviceHandler, &WscCPHandle, &WscCPHandle);
if (rc != UPNP_E_SUCCESS)
{
DBGPRINTF(RT_DBG_ERROR, "Error registering CP: %d\n", rc);
return WSC_SYS_ERROR;
}
DBGPRINTF(RT_DBG_INFO, "Control Point Registered\n");
WscUPnPCPRefresh();
// start a timer thread
if(rc == 0)
return WSC_SYS_SUCCESS;
}
int dial_init() {
list_init(&devices);
int status = UpnpInit(NULL, 0);
UpnpRegisterClient(callback, NULL, &handle);
return status;
}
int wphoto_upnp_handshake(void)
{
int ret = -1, err;
char descurl[256];
const char *desc_xml = "MobileDevDesc.xml";
struct timespec timer;
int camera_responded_save;
char *camera_url_save;
int pinged_camera;
ithread_mutex_init(&state_mutex, NULL);
ithread_cond_init(&state_cond, NULL);
camera_url = NULL;
camera_responded = 0;
err = UpnpInit(NULL, 0);
if (err != UPNP_E_SUCCESS) {
upnp_perror("UpnpInit", err);
goto err_init;
}
server_ip = UpnpGetServerIpAddress();
server_port = UpnpGetServerPort();
if (init_xml_docs() < 0) {
perror("init_xml_docs");
goto err_init;
}
printf("address: %s:%d\n", server_ip, server_port);
snprintf(descurl, sizeof(descurl), "http://%s:%d/%s",
server_ip, server_port, desc_xml);
err = web_add_callback("/MobileDevDesc.xml", web_MobileDevDesc, NULL);
if (err) {
perror("web_add_callback");
goto err_init;
}
err = web_add_callback("/desc_iml/CameraConnectedMobile.xml",
web_CameraConnectedMobile, NULL);
if (err) {
perror("web_add_callback");
goto err_init;
}
if (web_start() < 0) {
printf("web_init error\n");
goto err_init;
}
err = UpnpRegisterRootDevice(descurl, upnp_device_event_handler,
&device_handle, &device_handle);
if (err != UPNP_E_SUCCESS) {
upnp_perror("UpnpRegisterRootDevice", err);
goto err_init;
}
err = UpnpRegisterClient(upnp_client_event_handler,
&client_handle, &client_handle);
if (err != UPNP_E_SUCCESS) {
upnp_perror("UpnpRegisterClient", err);
goto err_register;
}
clock_gettime(CLOCK_REALTIME, &timer);
discovery_timeout = 1;
camera_responded_save = 0;
camera_url_save = NULL;
pinged_camera = 0;
do {
int wait_err;
if (!camera_responded_save) {
err = UpnpSendAdvertisement(device_handle, 0);
if (err != UPNP_E_SUCCESS) {
upnp_perror("UpnpSendAdvertisement", err);
goto err_register;
}
printf("NOTIFY sent\n");
}
if (camera_url_save && !pinged_camera)
if (ping_camera(camera_url_save) == 0)
pinged_camera = 1;
timer.tv_sec += ADVERTISEMENT_INTERVAL;
wait:
ithread_mutex_lock(&state_mutex);
wait_err = 0;
while (camera_responded == camera_responded_save &&
strcmp_null(camera_url, camera_url_save) == 0 &&
!discovery_timeout && wait_err == 0)
wait_err = ithread_cond_timedwait(
&state_cond, &state_mutex, &timer);
camera_responded_save = camera_responded;
if (strcmp_null(camera_url, camera_url_save) != 0) {
free(camera_url_save);
camera_url_save = strdup(camera_url);
}
/*
* Once we have the camera url, we stop sending M-SEARCH
* requests
*/
if (discovery_timeout && !camera_url_save) {
err = UpnpSearchAsync(client_handle, MSEARCH_INTERVAL,
CAMERA_SERVICE_NAME, (void*)42);
if (err != UPNP_E_SUCCESS) {
upnp_perror("UpnpSearchAsync", err);
goto err_register;
}
printf("M-SEARCH sent\n");
}
discovery_timeout = 0;
ithread_mutex_unlock(&state_mutex);
if (wait_err != ETIMEDOUT &&
(!pinged_camera || !camera_responded_save))
goto wait;
} while (!pinged_camera || !camera_responded_save);
return 0;
err_register:
UpnpUnRegisterRootDevice(device_handle);
err_init:
UpnpFinish();
return ret;
}
//////upnp init///////////////////////////////////
int init_upnp_ctl(void)
{
ithread_t timer_thread;
char * ip_address;
char *desc_doc_name;
char *web_dir_path;
char tmp_ipadd[20] ;//"192.168.61.22";
char tmp_namedoc[]="ctl_xml.xml";
unsigned short port;
int ret = UPNP_E_SUCCESS;
//= (*cyber_tem_ip)
char iptmp[20];
char * ip_data;
get_ip(iptmp);
port=80;
desc_doc_name=tmp_namedoc;
web_dir_path=DEFAULT_WEB_DIR;
//strcpy (cyber_tem_ip, tmp_ipadd);
ip_address =iptmp;//tmp_ipadd;
// creat_xml_file(iptmp);
// ithread_mutex_init( &TVDevMutex, NULL );
ithread_mutex_init( &DeviceListMutex, 0 );
printf("the iptmp is =%s\n",iptmp);
printf("zdy is ok1");
//printf("the tmp_ipadd=%s\n",tmp_ipadd);
/*
if( desc_doc_name == NULL )
desc_doc_name = tmp_namedoc;
printf("%s\n",*desc_doc_name);
if( web_dir_path == NULL )
web_dir_path = DEFAULT_WEB_DIR;
printf("%s\n",*web_dir_path);
*/
if((ret=UpnpInit(ip_address, port)) != UPNP_E_SUCCESS ) {
printf( "Error with UpnpInit -- %d\n", ret );
UpnpFinish( );
printf("%d\n", ret);
return ret;
}
if( ip_address == NULL )
{
ip_address = UpnpGetServerIpAddress( );
}
printf("ip_address is %s\n",ip_address);
if( port == 0 ) {
port = UpnpGetServerPort( );
}
printf( "UPnP Initialized\n ipaddress= %s port = %d\n",
ip_address, port );
// printf("zdy is ok1");
printf("bigin open the snprintf\n");
// snprintf( desc_doc_url, DESC_URL_SIZE, "http://%s:%d/cgi-bin/%s", ip_address,
// port, desc_doc_name );
printf("end the snprintf\n");
// printf("desc_doc_url %s",desc_doc_url);
ret=1;
if ((ret=UpnpRegisterClient( TvCtrlPointCallbackEventHandler,
&ctrlpt_handle, &ctrlpt_handle ))!=UPNP_E_SUCCESS)
{
printf( "Error registering the rootdevice : %d\n", ret );
UpnpFinish( );
return 0;
}
//
//TvCtrlPointRemoveAll( );
printf("TvCtrlPointRemoveAll\n");
ret=1;
printf("the TvDeviceType=%s\n",TvDeviceType);
Tvctrlpointrefresh();
ithread_create( &timer_thread, NULL, TvCtrlPointTimerLoop, NULL );
//sleep(5);
printf("ithread_create after\n");
}
/*
* Initializes UPNP instance.
*/
static int Open( vlc_object_t *p_this )
{
int i_res;
services_discovery_t *p_sd = ( services_discovery_t* )p_this;
services_discovery_sys_t *p_sys = ( services_discovery_sys_t * )
calloc( 1, sizeof( services_discovery_sys_t ) );
if( !( p_sd->p_sys = p_sys ) )
return VLC_ENOMEM;
#ifdef UPNP_ENABLE_IPV6
char* psz_miface;
psz_miface = var_InheritString( p_sd, "miface" );
msg_Info( p_sd, "Initializing libupnp on '%s' interface", psz_miface );
i_res = UpnpInit2( psz_miface, 0 );
free( psz_miface );
#else
/* If UpnpInit2 isnt available, initialize on first IPv4-capable interface */
i_res = UpnpInit( 0, 0 );
#endif
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Initialization failed: %s", UpnpGetErrorMessage( i_res ) );
free( p_sys );
return VLC_EGENERIC;
}
ixmlRelaxParser( 1 );
p_sys->p_server_list = new MediaServerList( p_sd );
vlc_mutex_init( &p_sys->callback_lock );
/* Register a control point */
i_res = UpnpRegisterClient( Callback, p_sd, &p_sys->client_handle );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Client registration failed: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* Search for media servers */
i_res = UpnpSearchAsync( p_sys->client_handle, 5,
MEDIA_SERVER_DEVICE_TYPE, p_sd );
if( i_res != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Error sending search request: %s", UpnpGetErrorMessage( i_res ) );
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
/* libupnp does not treat a maximum content length of 0 as unlimited
* until 64dedf (~ pupnp v1.6.7) and provides no sane way to discriminate
* between versions */
if( (i_res = UpnpSetMaxContentLength( INT_MAX )) != UPNP_E_SUCCESS )
{
msg_Err( p_sd, "Failed to set maximum content length: %s",
UpnpGetErrorMessage( i_res ));
Close( (vlc_object_t*) p_sd );
return VLC_EGENERIC;
}
return VLC_SUCCESS;
}
