void parse_service_list_descriptor_descriptor(unsigned char *buf)
{
/* Service list descriptor :
descriptor_tag 8
descriptor_length 8
for (i=0;i<N;I++){
service_id 8
service_type 16
}
*/
int i,service_id,service_type;
unsigned char descriptor_len = buf[1];
buf += 2;
log_message( log_module, MSG_DETAIL, "--- NIT descriptor --- Service list descriptor\n");
for(i=0;i<descriptor_len;i+=3)
{
service_id=(buf[i]<<8)+buf[i+1];;
service_type=buf[i+2];
log_message( log_module, MSG_DETAIL, "Service ID : 0x%02x service type: 0x%02x : %s \n",service_id, service_type, service_type_to_str(service_type));
}
log_message( log_module, MSG_DETAIL, "--- descriptor done ---\n");
}
/** @brief Send a basic JSON file containig the list of streamed channels
*
* @param number_of_channels the number of channels
* @param channels the channels array
* @param Socket the socket on wich the information have to be sent
*/
int unicast_send_streamed_channels_list_js (int number_of_channels, mumudvb_channel_t *channels, int Socket)
{
int curr_channel;
unicast_client_t *unicast_client=NULL;
int clients=0;
struct unicast_reply* reply = unicast_reply_init();
if (NULL == reply) {
log_message( log_module, MSG_INFO,"Error when creating the HTTP reply\n");
return -1;
}
unicast_reply_write(reply, "[");
for (curr_channel = 0; curr_channel < number_of_channels; curr_channel++)
{
clients=0;
unicast_client=channels[curr_channel].clients;
while(unicast_client!=NULL)
{
unicast_client=unicast_client->chan_next;
clients++;
}
unicast_reply_write(reply, "{\"number\":%d, \"lcn\":%d, \"name\":\"%s\", \"sap_group\":\"%s\", \"ip_multicast\":\"%s\", \"port_multicast\":%d, \"num_clients\":%d, \"scrambling_ratio\":%d, \"is_up\":%d, \"pcr_pid\":%d, \"pmt_version\":%d, ",
curr_channel+1,
channels[curr_channel].logical_channel_number,
channels[curr_channel].name,
channels[curr_channel].sap_group,
channels[curr_channel].ip4Out,
channels[curr_channel].portOut,
clients,
channels[curr_channel].ratio_scrambled,
channels[curr_channel].streamed_channel,
channels[curr_channel].pcr_pid,
channels[curr_channel].pmt_version );
unicast_reply_write(reply, "\"unicast_port\":%d, \"service_id\":%d, \"service_type\":\"%s\", \"pids_num\":%d, \n",
channels[curr_channel].unicast_port,
channels[curr_channel].service_id,
service_type_to_str(channels[curr_channel].channel_type),
channels[curr_channel].num_pids);
unicast_reply_write(reply, "\"pids\":[");
for(int i=0;i<channels[curr_channel].num_pids;i++)
unicast_reply_write(reply, "{\"number\":%d, \"type\":\"%s\", \"language\":\"%s\"},\n",
channels[curr_channel].pids[i],
pid_type_to_str(channels[curr_channel].pids_type[i]),
channels[curr_channel].pids_language[i]);
reply->used_body -= 2; // dirty hack to erase the last comma
unicast_reply_write(reply, "]");
unicast_reply_write(reply, "},\n");
}
reply->used_body -= 2; // dirty hack to erase the last comma
unicast_reply_write(reply, "]\n");
unicast_reply_send(reply, Socket, 200, "application/json");
if (0 != unicast_reply_free(reply)) {
log_message( log_module, MSG_INFO,"Error when releasing the HTTP reply after sendinf it\n");
return -1;
}
return 0;
}
/** @brief Convert the chained list of services into channels
*
* This function is called when We've got all the services, we now fill the channels structure
* After that we go in AUTOCONF_MODE_PIDS to get audio and video pids
* @param parameters The autoconf parameters
* @param channels Chained list of channels
* @param port The mulicast port
* @param card The card number for the ip address
* @param unicast_vars The unicast parameters
* @param fds The file descriptors (for filters and unicast)
*/
int autoconf_services_to_channels(autoconf_parameters_t parameters, mumudvb_channel_t *channels, int port, int card, int tuner, unicast_parameters_t *unicast_vars, multicast_parameters_t *multicast_vars, int server_id)
{
mumudvb_service_t *actual_service;
int channel_number=0;
int found_in_service_id_list;
int unicast_port_per_channel;
char tempstring[256];
actual_service=parameters.services;
unicast_port_per_channel=strlen(parameters.autoconf_unicast_port)?1:0;
do
{
if(parameters.autoconf_scrambled && actual_service->free_ca_mode)
log_message( log_module, MSG_DETAIL,"Service scrambled. Name \"%s\"\n", actual_service->name);
//If there is a service_id list we look if we find it (option autoconf_sid_list)
if(parameters.num_service_id)
{
int actual_service_id;
found_in_service_id_list=0;
for(actual_service_id=0;actual_service_id<parameters.num_service_id && !found_in_service_id_list;actual_service_id++)
{
if(parameters.service_id_list[actual_service_id]==actual_service->id)
{
found_in_service_id_list=1;
log_message( log_module, MSG_DEBUG,"Service found in the service_id list. Name \"%s\"\n", actual_service->name);
}
}
}
else //No ts id list so it is found
found_in_service_id_list=1;
if(!parameters.autoconf_scrambled && actual_service->free_ca_mode)
log_message( log_module, MSG_DETAIL,"Service scrambled, no CAM support and no autoconf_scrambled, we skip. Name \"%s\"\n", actual_service->name);
else if(!actual_service->pmt_pid)
log_message( log_module, MSG_DETAIL,"Service without a PMT pid, we skip. Name \"%s\"\n", actual_service->name);
else if(!found_in_service_id_list)
log_message( log_module, MSG_DETAIL,"Service NOT in the service_id list, we skip. Name \"%s\", id %d\n", actual_service->name, actual_service->id);
else //service is ok, we make it a channel
{
//Cf EN 300 468 v1.9.1 Table 81
if((actual_service->type==0x01||
actual_service->type==0x11||
actual_service->type==0x16||
actual_service->type==0x19)||
((actual_service->type==0x02||
actual_service->type==0x0a)&¶meters.autoconf_radios))
{
log_message( log_module, MSG_DETAIL,"We convert a new service into a channel, sid %d pmt_pid %d name \"%s\" \n",
actual_service->id, actual_service->pmt_pid, actual_service->name);
display_service_type(actual_service->type, MSG_DETAIL, log_module);
channels[channel_number].channel_type=actual_service->type;
channels[channel_number].num_packet = 0;
channels[channel_number].num_scrambled_packets = 0;
channels[channel_number].scrambled_channel = 0;
channels[channel_number].streamed_channel = 1;
channels[channel_number].nb_bytes=0;
channels[channel_number].pids[0]=actual_service->pmt_pid;
channels[channel_number].pids_type[0]=PID_PMT;
channels[channel_number].num_pids=1;
snprintf(channels[channel_number].pids_language[0],4,"%s","---");
if(strlen(parameters.name_template))
{
strcpy(channels[channel_number].name,parameters.name_template);
int len=MAX_NAME_LEN;
char number[10];
mumu_string_replace(channels[channel_number].name,&len,0,"%name",actual_service->name);
sprintf(number,"%d",channel_number+1);
mumu_string_replace(channels[channel_number].name,&len,0,"%number",number);
//put LCN here
}
else
strcpy(channels[channel_number].name,actual_service->name);
if(multicast_vars->multicast)
{
char number[10];
char ip[80];
int len=80;
if(strlen(parameters.autoconf_multicast_port))
{
strcpy(tempstring,parameters.autoconf_multicast_port);
sprintf(number,"%d",channel_number);
mumu_string_replace(tempstring,&len,0,"%number",number);
sprintf(number,"%d",card);
mumu_string_replace(tempstring,&len,0,"%card",number);
sprintf(number,"%d",tuner);
mumu_string_replace(tempstring,&len,0,"%tuner",number);
sprintf(number,"%d",server_id);
mumu_string_replace(tempstring,&len,0,"%server",number);
channels[channel_number].portOut=string_comput(tempstring);
}
else
{
channels[channel_number].portOut=port;//do here the job for evaluating the string
}
if(multicast_vars->multicast_ipv4)
{
strcpy(ip,parameters.autoconf_ip4);
sprintf(number,"%d",channel_number);
mumu_string_replace(ip,&len,0,"%number",number);
sprintf(number,"%d",card);
mumu_string_replace(ip,&len,0,"%card",number);
sprintf(number,"%d",tuner);
mumu_string_replace(ip,&len,0,"%tuner",number);
sprintf(number,"%d",server_id);
mumu_string_replace(ip,&len,0,"%server",number);
strcpy(channels[channel_number].ip4Out,ip);
log_message( log_module, MSG_DEBUG,"Channel IPv4 : \"%s\" port : %d\n",channels[channel_number].ip4Out,channels[channel_number].portOut);
}
if(multicast_vars->multicast_ipv6)
{
strcpy(ip,parameters.autoconf_ip6);
sprintf(number,"%d",channel_number);
mumu_string_replace(ip,&len,0,"%number",number);
sprintf(number,"%d",card);
mumu_string_replace(ip,&len,0,"%card",number);
sprintf(number,"%d",tuner);
mumu_string_replace(ip,&len,0,"%tuner",number);
sprintf(number,"%d",server_id);
mumu_string_replace(ip,&len,0,"%server",number);
strcpy(channels[channel_number].ip6Out,ip);
log_message( log_module, MSG_DEBUG,"Channel IPv6 : \"%s\" port : %d\n",channels[channel_number].ip6Out,channels[channel_number].portOut);
}
}
//This is a scrambled channel, we will have to ask the cam for descrambling it
if(parameters.autoconf_scrambled && actual_service->free_ca_mode)
channels[channel_number].need_cam_ask=CAM_NEED_ASK;
//We store the PMT and the service id in the channel
channels[channel_number].pmt_pid=actual_service->pmt_pid;
channels[channel_number].service_id=actual_service->id;
init_rtp_header(&channels[channel_number]); //We init the rtp header in all cases
if(channels[channel_number].pmt_packet==NULL)
{
channels[channel_number].pmt_packet=malloc(sizeof(mumudvb_ts_packet_t));
if(channels[channel_number].pmt_packet==NULL)
{
log_message( log_module, MSG_ERROR,"Problem with malloc : %s file : %s line %d\n",strerror(errno),__FILE__,__LINE__);
Interrupted=ERROR_MEMORY<<8;
return -1;
}
memset (channels[channel_number].pmt_packet, 0, sizeof( mumudvb_ts_packet_t));//we clear it
pthread_mutex_init(&channels[channel_number].pmt_packet->packetmutex,NULL);
}
#ifdef ENABLE_CAM_SUPPORT
//We allocate the packet for storing the PMT for CAM purposes
if(channels[channel_number].cam_pmt_packet==NULL)
{
channels[channel_number].cam_pmt_packet=malloc(sizeof(mumudvb_ts_packet_t));
if(channels[channel_number].cam_pmt_packet==NULL)
{
log_message( log_module, MSG_ERROR,"Problem with malloc : %s file : %s line %d\n",strerror(errno),__FILE__,__LINE__);
Interrupted=ERROR_MEMORY<<8;
return -1;
}
memset (channels[channel_number].cam_pmt_packet, 0, sizeof( mumudvb_ts_packet_t));//we clear it
pthread_mutex_init(&channels[channel_number].cam_pmt_packet->packetmutex,NULL);
}
#endif
//We update the unicast port, the connection will be created in autoconf_finish_full
if(unicast_port_per_channel && unicast_vars->unicast)
{
strcpy(tempstring,parameters.autoconf_unicast_port);
int len;len=256;
char number[10];
sprintf(number,"%d",channel_number);
mumu_string_replace(tempstring,&len,0,"%number",number);
sprintf(number,"%d",card);
mumu_string_replace(tempstring,&len,0,"%card",number);
sprintf(number,"%d",tuner);
mumu_string_replace(tempstring,&len,0,"%tuner",number);
sprintf(number,"%d",server_id);
mumu_string_replace(tempstring,&len,0,"%server",number);
channels[channel_number].unicast_port=string_comput(tempstring);
log_message( log_module, MSG_DEBUG,"Channel (direct) unicast port %d\n",channels[channel_number].unicast_port);
}
#ifdef ENABLE_TRANSCODING
//We copy the common transcode options to the new channel
transcode_copy_options(&global_transcode_opt,&channels[channel_number].transcode_options);
transcode_options_apply_templates(&channels[channel_number].transcode_options,card,tuner,server_id,channel_number);
#endif
channel_number++;
}
else if(actual_service->type==0x02||actual_service->type==0x0a) //service_type digital radio sound service
log_message( log_module, MSG_DETAIL,"Service type digital radio sound service, no autoconfigure. (if you want add autoconf_radios=1 to your configuration file) Name \"%s\"\n",actual_service->name);
else if(actual_service->type!=0) //0 is an empty service
{
//We show the service type
log_message( log_module, MSG_DETAIL,"No autoconfigure due to service type : %s. Name \"%s\"\n",service_type_to_str(actual_service->type),actual_service->name);
}
}
actual_service=actual_service->next;
}
while(actual_service && channel_number<MAX_CHANNELS);
if(channel_number==MAX_CHANNELS)
log_message( log_module, MSG_WARN,"Warning : We reached the maximum channel number, we drop other possible channels !\n");
return channel_number;
}
/** @brief Send a full XML state of the mumudvb instance
*
* @param number_of_channels the number of channels
* @param channels the channels array
* @param Socket the socket on wich the information have to be sent
* @param fds the frontend device structure
*/
int
unicast_send_xml_state (int number_of_channels, mumudvb_channel_t *channels, int Socket, strength_parameters_t *strengthparams, auto_p_t *auto_p, void *cam_p_v, void *scam_vars_v)
{
#ifndef ENABLE_CAM_SUPPORT
(void) cam_p_v; //to make compiler happy
#else
cam_p_t *cam_p=(cam_p_t *)cam_p_v;
#endif
#ifndef ENABLE_SCAM_SUPPORT
(void) scam_vars_v; //to make compiler happy
#else
scam_parameters_t *scam_vars=(scam_parameters_t *)scam_vars_v;
#endif
// Prepare the HTTP reply
struct unicast_reply* reply = unicast_reply_init();
if (NULL == reply) {
log_message( log_module, MSG_INFO,"Error when creating the HTTP reply\n");
return -1;
}
// Date time formatting
time_t rawtime;
time (&rawtime);
char sdatetime[25];
snprintf(sdatetime,25,"%s",ctime(&rawtime));
// XML header
unicast_reply_write(reply, "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
// Starting XML content
unicast_reply_write(reply, "<mumudvb card=\"%d\" frontend=\"%d\">\n",strengthparams->tune_p->card,strengthparams->tune_p->tuner);
// Mumudvb information
unicast_reply_write(reply, "\t<global_version><![CDATA[%s]]></global_version>\n",VERSION);
unicast_reply_write(reply, "\t<global_pid>%d</global_pid>\n",getpid ());
// Uptime
extern long real_start_time;
struct timeval tv;
gettimeofday (&tv, (struct timezone *) NULL);
unicast_reply_write(reply, "\t<global_uptime>%d</global_uptime>\n",(tv.tv_sec - real_start_time));
// Frontend setup
unicast_reply_write(reply, "\t<frontend_name><![CDATA[%s]]></frontend_name>\n",strengthparams->tune_p->fe_name);
unicast_reply_write(reply, "\t<frontend_tuned>%d</frontend_tuned>\n",strengthparams->tune_p->card_tuned);
if (strengthparams->tune_p->fe_type==FE_QPSK) // Do some test for always showing frequency in kHz
{
unicast_reply_write(reply, "\t<frontend_frequency>%d</frontend_frequency>\n",strengthparams->tune_p->freq);
unicast_reply_write(reply, "\t<frontend_satnumber>%d</frontend_satnumber>\n",strengthparams->tune_p->sat_number);
}
else
unicast_reply_write(reply, "\t<frontend_frequency>%d</frontend_frequency>\n",(strengthparams->tune_p->freq)/1000);
if (strengthparams->tune_p->pol==0)
unicast_reply_write(reply, "\t<frontend_polarization><![CDATA[-]]></frontend_polarization>\n");
else
unicast_reply_write(reply, "\t<frontend_polarization><![CDATA[%c]]></frontend_polarization>\n",strengthparams->tune_p->pol);
unicast_reply_write(reply, "\t<frontend_symbolrate>%d</frontend_symbolrate>\n",strengthparams->tune_p->srate);
// Frontend type
char fetype[10]="Unkonwn";
if (strengthparams->tune_p->fe_type==FE_OFDM)
#ifdef DVBT2
if (strengthparams->tune_p->delivery_system==SYS_DVBT2)
snprintf(fetype,10,"DVB-T2");
else
snprintf(fetype,10,"DVB-T");
#else
snprintf(fetype,10,"DVB-T");
#endif
if (strengthparams->tune_p->fe_type==FE_QAM) snprintf(fetype,10,"DVB-C");
if (strengthparams->tune_p->fe_type==FE_ATSC) snprintf(fetype,10,"ATSC");
if (strengthparams->tune_p->fe_type==FE_QPSK)
{
#if DVB_API_VERSION >= 5
if (strengthparams->tune_p->delivery_system==SYS_DVBS2)
snprintf(fetype,10,"DVB-S2");
#ifdef DVBT2
else if (strengthparams->tune_p->delivery_system==SYS_DVBT2)
snprintf(fetype,10,"DVB-T2");
#endif
else
snprintf(fetype,10,"DVB-S");
#else
snprintf(fetype,10,"DVB-S");
#endif
}
unicast_reply_write(reply, "\t<frontend_system><![CDATA[%s]]></frontend_system>\n",fetype);
// Frontend status
char SCVYL[6]="-----";
if (strengthparams->festatus & FE_HAS_SIGNAL) SCVYL[0]=83; // S
if (strengthparams->festatus & FE_HAS_CARRIER) SCVYL[1]=67; // C
if (strengthparams->festatus & FE_HAS_VITERBI) SCVYL[2]=86; // V
if (strengthparams->festatus & FE_HAS_SYNC) SCVYL[3]=89; // Y
if (strengthparams->festatus & FE_HAS_LOCK) SCVYL[4]=76; // L
SCVYL[5]=0;
unicast_reply_write(reply, "\t<frontend_status><![CDATA[%s]]></frontend_status>\n",SCVYL);
// Frontend signal
unicast_reply_write(reply, "\t<frontend_ber>%d</frontend_ber>\n",strengthparams->ber);
unicast_reply_write(reply, "\t<frontend_signal>%d</frontend_signal>\n",strengthparams->strength);
unicast_reply_write(reply, "\t<frontend_snr>%d</frontend_snr>\n",strengthparams->snr);
unicast_reply_write(reply, "\t<frontend_ub>%d</frontend_ub>\n",strengthparams->ub);
unicast_reply_write(reply, "\t<ts_discontinuities>%d</ts_discontinuities>\n",strengthparams->ts_discontinuities);
// Autoconfiguration state
if (auto_p->autoconfiguration!=0)
unicast_reply_write(reply, "\t<autoconf_end>%d</autoconf_end>\n",0);
else
unicast_reply_write(reply, "\t<autoconf_end>%d</autoconf_end>\n",1);
// CAM information
#ifdef ENABLE_CAM_SUPPORT
unicast_reply_write(reply, "\t<cam_support>%d</cam_support>\n",cam_p->cam_support);
unicast_reply_write(reply, "\t<cam_number>%d</cam_number>\n",cam_p->cam_number);
unicast_reply_write(reply, "\t<cam_menustring><![CDATA[%s]]></cam_menustring>\n",cam_p->cam_menu_string.string);
unicast_reply_write(reply, "\t<cam_initialized>%d</cam_initialized>\n",cam_p->ca_resource_connected);
#else
unicast_reply_write(reply, "\t<cam_support>%d</cam_support>\n",0);
unicast_reply_write(reply, "\t<cam_number>%d</cam_number>\n",0);
unicast_reply_write(reply, "\t<cam_menustring><![CDATA[No CAM support]]></cam_menustring>\n");
unicast_reply_write(reply, "\t<cam_initialized>%d</cam_initialized>\n",0);
#endif
// SCAM information
#ifdef ENABLE_SCAM_SUPPORT
unicast_reply_write(reply, "\t<scam_support>%d</scam_support>\n",scam_vars->scam_support);
if (scam_vars->scam_support) {
unicast_reply_write(reply, "\t<ring_buffer_default_size>%u</ring_buffer_default_size>\n",scam_vars->ring_buffer_default_size);
unicast_reply_write(reply, "\t<decsa_default_delay>%u</decsa_default_delay>\n",scam_vars->decsa_default_delay);
unicast_reply_write(reply, "\t<send_default_delay>%u</send_default_delay>\n",scam_vars->send_default_delay);
}
else {
unicast_reply_write(reply, "\t<ring_buffer_default_size>%u</ring_buffer_default_size>\n",0);
unicast_reply_write(reply, "\t<decsa_default_delay>%u</decsa_default_delay>\n",0);
unicast_reply_write(reply, "\t<send_default_delay>%u</send_default_delay>\n",0);
}
#else
unicast_reply_write(reply, "\t<scam_support>%d</scam_support>\n",0);
unicast_reply_write(reply, "\t<ring_buffer_default_size>%u</ring_buffer_default_size>\n",0);
unicast_reply_write(reply, "\t<decsa_default_delay>%u</decsa_default_delay>\n",0);
unicast_reply_write(reply, "\t<send_default_delay>%u</send_default_delay>\n",0);
#endif
// Channels list
int curr_channel;
for (curr_channel = 0; curr_channel < number_of_channels; curr_channel++)
{
unicast_reply_write(reply, "\t<channel number=\"%d\" is_up=\"%d\">\n",curr_channel+1,channels[curr_channel].streamed_channel);
unicast_reply_write(reply, "\t\t<lcn>%d</lcn>\n",channels[curr_channel].logical_channel_number);
unicast_reply_write(reply, "\t\t<name><![CDATA[%s]]></name>\n",channels[curr_channel].name);
unicast_reply_write(reply, "\t\t<service_type type=\"%d\"><![CDATA[%s]]></service_type>\n",channels[curr_channel].channel_type,service_type_to_str(channels[curr_channel].channel_type));
if (channels[curr_channel].portOut==0)
unicast_reply_write(reply, "\t\t<ip_multicast><![CDATA[0.0.0.0]]></ip_multicast>\n");
else
unicast_reply_write(reply, "\t\t<ip_multicast><![CDATA[%s]]></ip_multicast>\n",channels[curr_channel].ip4Out);
unicast_reply_write(reply, "\t\t<port_multicast>%d</port_multicast>\n",channels[curr_channel].portOut);
unicast_reply_write(reply, "\t\t<traffic>%.0f</traffic>\n",channels[curr_channel].traffic);
unicast_reply_write(reply, "\t\t<ratio_scrambled>%d</ratio_scrambled>\n",channels[curr_channel].ratio_scrambled);
unicast_reply_write(reply, "\t\t<service_id>%d</service_id>\n",channels[curr_channel].service_id);
unicast_reply_write(reply, "\t\t<pmt_pid>%d</pmt_pid>\n",channels[curr_channel].pmt_pid);
unicast_reply_write(reply, "\t\t<pmt_version>%d</pmt_version>\n",channels[curr_channel].pmt_version);
unicast_reply_write(reply, "\t\t<pcr_pid>%d</pcr_pid>\n",channels[curr_channel].pcr_pid);
unicast_reply_write(reply, "\t\t<unicast_port>%d</unicast_port>\n",channels[curr_channel].unicast_port);
// SCAM information
#ifdef ENABLE_SCAM_SUPPORT
if (scam_vars->scam_support) {
unicast_reply_write(reply, "\t\t<scam descrambled=\"%d\">\n",channels[curr_channel].scam_support);
if (channels[curr_channel].scam_support) {
unsigned int ring_buffer_num_packets = 0;
if (channels[curr_channel].ring_buf) {
pthread_mutex_lock(&channels[curr_channel].ring_buf->lock);
ring_buffer_num_packets = channels[curr_channel].ring_buf->to_descramble + channels[curr_channel].ring_buf->to_send;
pthread_mutex_unlock(&channels[curr_channel].ring_buf->lock);
}
unicast_reply_write(reply, "\t\t\t<ring_buffer_size>%u</ring_buffer_size>\n",channels[curr_channel].ring_buffer_size);
unicast_reply_write(reply, "\t\t\t<decsa_delay>%u</decsa_delay>\n",channels[curr_channel].decsa_delay);
unicast_reply_write(reply, "\t\t\t<send_delay>%u</send_delay>\n",channels[curr_channel].send_delay);
unicast_reply_write(reply, "\t\t\t<num_packets>%u</num_packets>\n",ring_buffer_num_packets);
}
unicast_reply_write(reply, "\t\t</scam>\n");
}
#endif
unicast_reply_write(reply, "\t\t<ca_sys>\n");
for(int i=0;i<32;i++)
if(channels[curr_channel].ca_sys_id[i]!=0)
unicast_reply_write(reply, "\t\t\t<ca num=\"%d\"><![CDATA[%s]]></ca>\n",channels[curr_channel].ca_sys_id[i],ca_sys_id_to_str(channels[curr_channel].ca_sys_id[i]));
unicast_reply_write(reply, "\t\t</ca_sys>\n");
unicast_reply_write(reply, "\t\t<pids>\n");
for(int i=0;i<channels[curr_channel].num_pids;i++)
unicast_reply_write(reply, "\t\t\t<pid number=\"%d\" language=\"%s\" scrambled=\"%d\"><![CDATA[%s]]></pid>\n", channels[curr_channel].pids[i], channels[curr_channel].pids_language[i], channels[curr_channel].pids_scrambled[i], pid_type_to_str(channels[curr_channel].pids_type[i]));
unicast_reply_write(reply, "\t\t</pids>\n");
unicast_reply_write(reply, "\t</channel>\n");
}
// Ending XML content
unicast_reply_write(reply, "</mumudvb>\n");
unicast_reply_send(reply, Socket, 200, "application/xml; charset=UTF-8");
// End of HTTP reply
if (0 != unicast_reply_free(reply)) {
log_message( log_module, MSG_INFO,"Error when releasing the HTTP reply after sendinf it\n");
return -1;
}
return 0;
}
/** @brief Display the service type according to EN 300 468 v1.10.1 table 81
*
* @param type the type to display
* @param loglevel : the loglevel for displaying it
*/
void display_service_type(int type, int loglevel, char *log_module)
{
log_message( log_module, loglevel, "service type: 0x%x : %s \n", type, service_type_to_str(type));
}
