rtsp_error_t rtsp_phdr_content_len(rtsp_header_t *header, const char *msg, int32_t msg_len, const char **endptr){
const char *end = msg + msg_len;
unsigned long long ull_cseq = 0;
if(!header || !msg || msg_len <= 0){
return (RTSP_E_INVALID_ARG);
}
ull_cseq = strtoull(msg,(char **) endptr, 10);
/* TODO - Find strntoull and put it here
* Simple way is to swap last char with null char and then restore after computation*/
if(*endptr >= end){
ERR_LOG("Invalid Memory Access");
return (RTSP_E_INCOMPLETE);
}
if(ull_cseq > UINT_MAX){
ERR_LOG ("CSeq not supported beyond %u - occured (%llu)", UINT_MAX, ull_cseq);
return (RTSP_E_UNSUPPORTED);
}
header->content_len.bytes = ull_cseq;
return (RTSP_E_SUCCESS);
}
/*******************************************************************************
Function Definition
*******************************************************************************/
extern sint32 autolink_mcu_send_msg(sint32 times,uint8 cmd1,uint8* data,sint8 len)
{
uint8 reply[FRAME_LEN_MAX];
sint32 result = -1;
sint32 iter = 0;
reply[0] = MCU_SYNC_BYTE_0;
reply[1] = MCU_SYNC_BYTE_1;
reply[2] = MCU_FLAG_BYTE_NORMAL;
reply[4] = mcuinfo.arm_framecounter++;
reply[5] = cmd1;
reply[6] = MCU_ACK_BYTE_FALSE;
reply[7] = len;
memcpy(reply+8,data,len);
reply[3] = autolink_mcu_checksum(reply[2],reply+4,len+4);
while(iter < times){
if( len+8 == autolink_mcu_sendinfo(reply,len+8) ){
result = 0;
break;
}
iter++;
ERR_LOG("-------------------------------------------\n");
ERR_LOG("mcu send data failed %d times\n",iter);
ERR_LOG("-------------------------------------------\n");
}
return result;
}
/*******************************************************************************
Function
*******************************************************************************/
extern sint32 autolink_send_mcu_radio_set_freq(autolink_radio_st radio)
{
uint8 cmd;
uint8 msg_data[DATA_LEN_MAX];
uint8 len = 0;
cmd = MCU_CMD_RADIO;
msg_data[0] = MCU_RADIO_DATA0_ARMSET_FREQ;
DBG_LOG("SEND:set band %d\n",radio.set.band);
switch(radio.set.band)
{
case RADIO_BAND_FM:
msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_FM;
break;
case RADIO_BAND_AM:
msg_data[1] = MCU_RADIO_DATA1_ARMSET_BAND_AM;
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
DBG_LOG("SEND:set freq_position %d\n",radio.set.freq_position);
msg_data[2] = radio.set.freq_position;
DBG_LOG("SEND:set type %d\n",radio.set_type);
switch(radio.set_type)
{
case RADIO_SET_SELECT:
msg_data[3] = MCU_RADIO_DATA1_ARMSET_SELECT;
break;
case RADIO_SET_SAVE:
msg_data[3] = MCU_RADIO_DATA1_ARMSET_SAVE;
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
DBG_LOG("SEND:set freq %f\n",radio.set.freq);
switch(radio.set.band)
{
case RADIO_BAND_AM:
int_to_byte(radio.set.freq,NULL,NULL,&msg_data[4],&msg_data[5]);
break;
case RADIO_BAND_FM:
int_to_byte(radio.set.freq*100,NULL,NULL,&msg_data[4],&msg_data[5]);
break;
default:
ERR_LOG("UNKOWN MSG\n");
return -1;
}
len = 6;
return autolink_mcu_send_msg(1,cmd,msg_data,len);
}
char *r2adir(
char *indir)
{
char *mydir;
char *outdir;
char *ptr;
if (indir == NULL || indir[0] == 0)
{
LOG(LOG_ERR, "indir must not be NULL or an empty string");
return (NULL);
}
if (isadir(indir) <= 0)
return (NULL);
// get current dir
mydir = (char *)calloc(PATH_MAX, sizeof(char));
if (mydir == NULL)
{
LOG(LOG_ERR, "out of memory");
return (NULL);
}
outdir = (char *)calloc(PATH_MAX, sizeof(char));
if (outdir == NULL)
{
free((void *)mydir);
LOG(LOG_ERR, "out of memory");
return (NULL);
}
ptr = getcwd(mydir, PATH_MAX);
if (ptr == NULL)
{
free((void *)mydir);
free((void *)outdir);
ERR_LOG(errno, NULL, "failed to get current working directory");
return (NULL);
}
if (chdir(indir) < 0)
{
free((void *)mydir);
free((void *)outdir);
ERR_LOG(errno, NULL, "failed to change directory to %s", indir);
return (NULL);
}
ptr = getcwd(outdir, PATH_MAX);
if (chdir(mydir))
abort();
free((void *)mydir);
if (ptr == NULL)
{
free((void *)outdir);
ERR_LOG(errno, NULL, "unable to get current working directory");
return (NULL);
}
return (outdir);
}
/*****************************************************************************
Function : IsSupportCpuHotplug
Description: get os info to detect if os support cpu hotplug
Input : None
Output : None
Return : TRUE or FALSE
*****************************************************************************/
int IsSupportCpuHotplug(void)
{
int ret = 0;
char *pszHotplugFlagScript = "uname_str=`uname -r`;"
"cpu_hotplug_conf=`grep 'CONFIG_HOTPLUG_CPU' /boot/config-$uname_str 2>/dev/null | awk -F= '{print $2}'`;"
"printf $cpu_hotplug_conf 2>/dev/null ;";
char pszHotplugFlag[1024] = {0};
ret = uvpPopen(pszHotplugFlagScript, pszHotplugFlag, 1024);
if (0 != ret)
{
ERR_LOG("Failed to call uvpPopen, ret=%d.", ret);
return ret;
}
if (0 == strcmp("y", pszHotplugFlag))
{
return XEN_SUCC;
}
else
{
INFO_LOG("This OS is not supported cpu hotplug.");
return XEN_FAIL;
}
}
int camera_flash_register(struct camera_flash_dev *tdev)
{
int ret;
if (!tdev || !tdev->name || !tdev->enable || !tdev->get){
return -EINVAL;
}
tdev->index = atomic_inc_return(&device_count);
tdev->dev = device_create(msm_camera_flash_class, NULL, MKDEV(0, tdev->index), NULL, tdev->name);
if (IS_ERR(tdev->dev)){
return PTR_ERR(tdev->dev);
}
ret = device_create_file(tdev->dev, &dev_attr_camera_flash);
if (ret < 0){
goto err_create_file;
}
dev_set_drvdata(tdev->dev, tdev);
tdev->state = 0;
return 0;
err_create_file:
device_destroy(msm_camera_flash_class, MKDEV(0, tdev->index));
ERR_LOG(KERN_ERR "cabc: Failed to register driver %s\n", tdev->name);
return ret;
}
/**
* name_lost_cb - The GDBusConnection on which to acquire the name
* or NULL if the connection was disconnected.
*
* @connection: The GDBusConnection on which to acquired the name
* @bus_name : The bus name being owned
* @user_data :
*
* returns:
* void
*
*/
static void
name_lost_cb(GDBusConnection *connection,
const gchar *bus_name,
gpointer user_data)
{
if(connection == NULL)
{
ERR_LOG ("name_lost_cb Error: Failed to connect to dbus.\n");
}
else
{
ERR_LOG ("name_lost_cb Error: Failed to obtain bus name: %s.\n", bus_name);
}
g_main_loop_quit(mainloop);
}
/**
* bus_acquired_cb - handler to invoke when connected to the bus
* of type bus_type or NULL.
*
* @connection: The GDBusConnection to a message bus
* @bus_name : The name that is requested to be owned
* @user_data :
*
* returns:
* void
*
*/
static void
bus_acquired_cb(GDBusConnection *connection,
const gchar *bus_name,
gpointer user_data)
{
GError *pError = NULL;
gchar *obj_path = user_data;
INFO_LOG ("bus_acquired_cb ,Acquired session bus.\n");
/** Second step: Try to get a connection to the given bus. */
pSkeleton = gdbus_mcuinfo_skeleton_new();
/** Third step: Attach to dbus signals. */
(void) g_signal_connect(pSkeleton, "handle-send-mcuinfo", G_CALLBACK(method_send_mcuinfo), NULL);
/** Fourth step: Export interface skeleton. */
(void) g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(pSkeleton),
connection,
obj_path,//AUTOLINK_GDBUS_BUS_OBJECT_PATH,
&pError);
if(pError != NULL){
ERR_LOG ("bus_acquired_cb: Failed to export object. Reason: %s.\n", pError->message);
g_error_free(pError);
g_main_loop_quit(mainloop);
}
}
/*******************************************************************************
Function
*******************************************************************************/
static void autolink_mcu_parse_radio_savereq(uint8* data,uint32 len)
{
sint32 freq = byte_to_int(0,0,data[2],data[3]);
switch(data[0])
{
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_FM:
mcu_info_data.radio.save.band = RADIO_BAND_FM;
mcu_info_data.radio.save.freq = (float)freq/100;
DBG_LOG("GET:save freq FM %f\n",mcu_info_data.radio.save.freq);
break;
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_AM:
mcu_info_data.radio.save.band = RADIO_BAND_AM;
mcu_info_data.radio.save.freq = freq;
DBG_LOG("GET:save freq AM %d\n",mcu_info_data.radio.save.freq);
break;
default:
ERR_LOG("GET:save freq unkown\n");
return;
}
mcu_info_data.radio.save.freq_position = data[1];
DBG_LOG("GET:save freq radio position %d\n",mcu_info_data.radio.save.freq_position);
autolink_emit_mcu_state(TYPE_RADIO_SAVEFREQ,mcu_info_data);
return;
}
/*****************************************************************************
Function : GetSupportMaxnumCpu
Description: cpu hotplug support the maxnum cpu
Input : None
Output : None
Return : return the maxnum
*****************************************************************************/
int GetSupportMaxnumCpu(void)
{
int ret = 0;
int cpu_nr = 0;
char *pszSysCpuNumScript = "uname_str=`uname -r`;"
"syscpu_enable_num=`grep 'CONFIG_NR_CPUS' /boot/config-$uname_str 2>/dev/null | awk -F= '{print($2)}'`;"
"printf $syscpu_enable_num 2>/dev/null ;";
char pszSysCpuNum[1024] = {0};
ret = uvpPopen(pszSysCpuNumScript, pszSysCpuNum, 1024);
if (0 != ret)
{
ERR_LOG("Failed to call uvpPopen, ret=%d.", ret);
return ret;
}
cpu_nr = strtoul(pszSysCpuNum, NULL, 10);
/*lint -e648 */
if (ULONG_MAX == cpu_nr)
{
return -ERANGE;
}
/*lint +e648 */
else if (cpu_nr <= CPU_NR_MAX)
{
return cpu_nr;
}
else
{
return CPU_NR_MAX;
}
}
int is_redhat()
{
FILE *pF = NULL;
char strIssue[SHELL_BUFFER] = {0};
if(0 == access("/etc/redhat-release", R_OK))
{
return 1;
}
pF = fopen("/etc/issue", "r");
if (NULL == pF)
{
ERR_LOG("[Monitor-Upgrade]: open /etc/issue fail.");
return 0;
}
while(fgets(strIssue, SHELL_BUFFER-1, pF) != NULL)
{
if (strstr(strIssue, "Red Hat") || strstr(strIssue, "GreatTurbo"))
{
fclose(pF);
return 1;
}
}
fclose(pF);
return 0;
}
int isdebian()
{
FILE *pF = NULL;
char strIssue[SHELL_BUFFER] = {0};
if(0 == access("/etc/debian_version", R_OK))
{
return 1;
}
pF = fopen("/etc/issue", "r");
if (NULL == pF)
{
ERR_LOG("[Monitor-Upgrade]: open /etc/issue fail.");
return 0;
}
while(fgets(strIssue, SHELL_BUFFER-1, pF) != NULL)
{
if (strstr(strIssue, "Debian"))
{
fclose(pF);
return 1;
}
}
fclose(pF);
return 0;
}
/*******************************************************************************
Function Definition
*******************************************************************************/
static void autolink_mcu_packet_parse(uint8 cmd1,uint8* data, sint8 len)
{
DBG_LOG("NEW MSG\n");
DBG_LOG("CMD1=%X\n",cmd1);
switch(cmd1)
{
case MCU_CMD_SYSTEM:
autolink_mcu_parse_system(data,len);
break;
case MCU_CMD_KEY:
autolink_mcu_parse_key(data,len);
break;
case MCU_CMD_RADIO:
autolink_mcu_parse_radio(data,len);
break;
case MCU_CMD_SETTING:
autolink_mcu_parse_setting(data,len);
break;
case MCU_CMD_MEDIA:
autolink_mcu_parse_media(data,len);
break;
case MCU_CMD_UPDATE:
autolink_mcu_parse_update(data,len);
break;
case MCU_CMD_CAN:
autolink_mcu_parse_can(data,len);
break;
default:
ERR_LOG("UNKOWN MSG\n");
break;
}
return ;
}
/*****************************************************************************
Function : GetIpv4VifIp
Description: get Ipv4 ip info
Input : None
Output : None
Return :
*****************************************************************************/
int GetIpv4VifIp(int skt, int num, char *ifname)
{
struct ifaddrs *ifaddr, *ifa;
int ret;
char address[IPV6_ADDR_LEN];
if (getifaddrs(&ifaddr) == -1)
{
ERR_LOG("Call getifaddrs failed, errno=%d", errno);
return ERROR;
}
for (ifa = ifaddr; ifa; ifa = ifa->ifa_next)
{
if (NULL == ifa->ifa_addr)
continue;
if( AF_INET != ifa->ifa_addr->sa_family)
continue;
ret = getnameinfo(ifa->ifa_addr,sizeof(struct sockaddr_in),address, IPV6_ADDR_LEN, NULL, 0, NI_NUMERICHOST);
if (0 != ret)
{
ERR_LOG("Call getnameinfo for nic %s failed: %s.", ifname, gai_strerror(ret));
continue;
}
if((NULL != ifa->ifa_name) && (strcmp(ifa->ifa_name,ifname) == 0) && (AF_INET == ifa->ifa_addr->sa_family))
{
snprintf_s(gtNicIpv6Info.info[gtNicIpv6Info.count].ifname, VIF_NAME_LENGTH, VIF_NAME_LENGTH, "%s", ifname);
GetIpv6VifMac(skt,ifname);
gtNicIpv6Info.info[gtNicIpv6Info.count].ipversionflag = 4;
snprintf_s(gtNicIpv6Info.info[gtNicIpv6Info.count].ipaddr, IPV6_ADDR_LEN, IPV6_ADDR_LEN, "%s", address);
GetIpv4VifGateway(skt, ifname);
GetIpv6Flux(skt,ifname);
GetIpv6NetFlag(skt,ifname);
num++;
gtNicIpv6Info.count = num;
}
}
freeifaddrs(ifaddr);
return gtNicIpv6Info.count;
}
void _general_exception_handler(unsigned cause, unsigned status)
{
Nop();
#if defined(TEST)
{
memcpypgm2ram(Err_String,"C32 GENRAl EXECPTION",19);
ERR_LOG (Err_String);
}
#endif
Nop();
}
uint32_t trunk_ssp_get_global_index( uint32_t slot, uint32_t port, uint32_t *port_index)
{
uint32_t ret = 0;
if (port == 0)
{
ERR_LOG(ret, slot, port, 0);
return M_LACP_INTERNEL;
}
*port_index = slot * 8 + (port - 1) ;
return 0;
}
/** Test wether unnamed semaphores are supported. */
static void initialize_support_unnamed()
{
char errorbuf[ERROR_BUF_SIZE];
sem_t test_sem;
if (sem_init(&test_sem, 0, 0) == 0)
{
support_unnamed = true;
if (sem_destroy(&test_sem) != 0)
{
ERR_LOG(errno, errorbuf, "sem_destroy()");
}
}
else
{
switch (errno)
{
case ENOSYS:
support_unnamed = false;
break;
default:
// It /might/ be a temporary error, so just log it and move on.
ERR_LOG(errno, errorbuf, "sem_init()");
support_unnamed = true;
break;
}
}
if (support_unnamed)
{
LOG(LOG_DEBUG, "system appears to support unnamed semaphores");
}
else
{
LOG(LOG_DEBUG, "system does not appear to support unnamed semaphores");
}
}
/*******************************************************************************
Function
*******************************************************************************/
extern void autolink_mcu_parse_system(uint8 cmd2,uint8* data,uint32 len)
{
DBG_LOG("CMD2=%X\n",cmd2);
switch(cmd2)
{
case MCU_SYSTEM_CMD2_HANDSHAKE:
autolink_mcu_parse_system_handshake(data,len);
break;
default:
ERR_LOG("UNKOWN MSG\n");
break;
}
return ;
}
/**
* autolink_dbusclient_init - Linux app management
*
* @pdbusclient: dbus server struct
*
* returns:
* 0 - ok, other - err
*/
extern gint32
autolink_dbusclient_deinit(autolink_dbusclient_ptr pdbusclient)
{
if (pdbusclient == NULL) return ERR_PARAMENT;
if (pdbusclient->tid_client == 0) {
ERR_LOG ("dbus client thread isn't alive.\n");
return ERR_CONDITION;
}
/* Stop a GMainLoop from running */
g_main_loop_quit (pdbusclient->mainloop);
g_main_loop_unref (pdbusclient->mainloop);
/* wait client thread end */
pthread_join (pdbusclient->tid_client, NULL);
return ERR_OK;
}
/*******************************************************************************
Function
*******************************************************************************/
static void autolink_mcu_parse_system_handshake(uint8* data,uint32 len)
{
switch(data[0])
{
case MCU_SYSTEM_DATA0_HANDSHAKE:
mcuinfo_system.handshake = MCU_SYSTEM_HANDSHAKE_TRUE;
DBG_LOG("GET:mcu handshake successful info\n");
break;
default:
ERR_LOG("GET:handshake unkown\n");
return;
}
return;
}
rtsp_error_t rtsp_phdr_session(rtsp_header_t *header, const char *msg, int32_t msg_len, const char **endptr){
const char *scan = NULL;
const char *scan_end = NULL;
const char *temp = NULL;
const char *end = msg + msg_len;
rtsp_error_t err = RTSP_E_FAILURE;
if(!header || !msg || msg_len <= 0){
return (RTSP_E_INVALID_ARG);
}
scan = msg;
header->session.id = scan;
while (scan < end && (isalnum(*scan) || is_safe(*scan)))
scan++;
header->session.id_len = scan-msg;
if(header->session.id_len > 0)
err = RTSP_E_SUCCESS;
if(*scan == ';'){
scan++;
scan_end = find_char(scan, end, '\r');
err = is_strncasematch(scan, scan_end, "timeout", STATIC_STR_LEN("timeout"));
if(err==RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("timeout");
if(*scan == '='){
scan++;
header->session.timeout = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Session timeout Error - Check Logic");
err = RTSP_E_FAILURE;
} else {
scan = temp;
}
}
}
}
if(endptr)
*endptr = scan;
return (err);
}
/**
* main - main function dbus client, to test libmedia
*
* @argc: para index
* @argv: param
*
*/
int
main (int argc, char **argv)
{
int ret;
autolink_dbusclient_st dbusclient = {0};
gchar mtd_out[BUF_LEN];
gchar mtd_err[BUF_LEN];
loginfo = autolink_loglevel_init("mcu-test",AUTOKINK_LOGLEVEL_2,AUTOKINK_LOGCTR_TRUE);
ret = autolink_dbusclient_init(&dbusclient, BUS_NAME, OBJ_PATH);
INFO_LOG ("dbus client init %s: %d.\n", (!ret)?"success":"fail", ret);
/* register up-layer signal callback func */
signal_callback_st sigfunc;
sigfunc.mcuinfo_cb = signal_mcuinfo_cb;
ret = autolink_reg_sigcallback (sigfunc);
INFO_LOG ("register up layer signal callback %s.\n", (!ret)?"success":"fail");
while (autolink_dbusservice_ready()) usleep (300*1000);
autolink_mcu_info_dbus_st mcu_info;
mcu_info.mcu_info_type = 5;
ret = autolink_mtdcall_sendmcuinfo (&mcu_info, mtd_out, mtd_err);
//INFO_LOG ("method 1 call %s: %d.\n", (!ret)?"success":"fail", ret);
if (ret == 0) {
INFO_LOG ("method send mcuinfo call success, mtd_out: %s.\n", mtd_out);
}
else if (ret == ERR_OTHER) {
ERR_LOG ("method send mcuinfo call fail: %s.\n", mtd_err);
}
INFO_LOG ("dbus-client is running.\n");
while (1)
{
sleep (2);
}
ret = autolink_dbusclient_deinit (&dbusclient);
INFO_LOG ("dbus client deinit %s: %d.\n", (!ret)?"success":"fail", ret);
}
static int child_busy(int fd)
{
int rc;
/* suicide if sched_yield fails */
alarm(4);
/* Tell the parent we're ready */
write(fd, "go", 2);
for (;;) {
rc = sched_yield();
if (rc) {
ERR_LOG("child: sched_yield", rc);
exit(1);
}
}
/* should not get here */
exit(2);
}
/*******************************************************************************
Function
*******************************************************************************/
static void autolink_mcu_parse_radio_all_savereq(uint8* data,uint32 len)
{
sint32 iter = 0;
sint32 band = RADIO_BAND_FM;
mcu_info_data.radio.allsave_count = data[1];
switch(data[0])
{
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_FM:
band = RADIO_BAND_FM;
DBG_LOG("GET:allsave freq FM\n");
break;
case MCU_RADIO_DATA1_ALREADY_SAVEFREQ_BAND_AM:
band = RADIO_BAND_AM;
DBG_LOG("GET:allsave freq AM\n");
break;
default:
ERR_LOG("GET:allsave freq unkown\n");
return;
}
while(iter < mcu_info_data.radio.allsave_count)
{
mcu_info_data.radio.allsave[iter].band = band;
if( RADIO_BAND_FM == band )
{
mcu_info_data.radio.allsave[iter].freq = (float)byte_to_int(0,0,data[2+iter*2],data[3+iter*2])/100;
}
else if( RADIO_BAND_AM == band )
{
mcu_info_data.radio.allsave[iter].freq = byte_to_int(0,0,data[2+iter*2],data[3+iter*2]);
}
DBG_LOG("GET:allsave freq %f\n",mcu_info_data.radio.allsave[iter].freq);
iter++;
}
autolink_emit_mcu_state(TYPE_RADIO_ALL_SAVEFREQ,mcu_info_data);
return;
}
int isadir(
char *indir)
{
struct stat mystat;
int sta;
if (indir == NULL || indir[0] == 0)
return (-1);
memset(&mystat, 0, sizeof(mystat));
sta = stat(indir, &mystat);
if (sta < 0)
{
ERR_LOG(errno, NULL, "stat(\"%s\") failed", indir);
return (sta);
}
if (S_ISDIR(mystat.st_mode))
return (1);
else
{
LOG(LOG_ERR, "%s is not a directory", indir);
return (0);
}
}
/*******************************************************************************
Function
*******************************************************************************/
extern void autolink_mcu_parse_radio(uint8* data,uint32 len)
{
DBG_LOG("CMD2=%X\n",data[0]);
switch(data[0])
{
case MCU_RADIO_DATA0_MAINFREQ:
autolink_mcu_parse_radio_mainfreq(data+1,len-1);
break;
case MCU_RADIO_DATA0_SAVEFREQ:
autolink_mcu_parse_radio_savereq(data+1,len-1);
break;
case MCU_RADIO_DATA0_ALREADY_SAVEFREQ:
autolink_mcu_parse_radio_all_savereq(data+1,len-1);
break;
case MCU_RADIO_DATA0_ARMSET_FREQ:
//ARM->MCU
break;
default:
ERR_LOG("UNKOWN MSG\n");
break;
}
return ;
}
/**
* autolink_dbusclient_init - Linux app management
*
* @pdbusclient : autolink_dbusclient_st
* @busname : dbus bus name, for example "org.autolink.AppMngService"
* @signame : signal name, for example "AppMngSignal"，Must be camel format
*
* returns:
*
*/
extern gint32
autolink_dbusclient_init(autolink_dbusclient_ptr pdbusclient, const char *busname, const char *objpath)
{
int ret;
gboolean bRet = TRUE;
GError *pConnError = NULL;
GError *pProxyError = NULL;
pthread_t tid_client;
if (pdbusclient == NULL || busname == NULL || objpath == NULL) return ERR_PARAMENT;
if (pdbusclient->tid_client != 0) return ERR_CONDITION;
g_type_init(); /** initial for usage of "g" types */
mainloop = g_main_loop_new (NULL, FALSE); /** create main loop, but do not start it.*/
do{
bRet = TRUE;
/** First step: get a connection */
pConnection = g_bus_get_sync (AUTOLINK_GDBUS_BUS, NULL, &pConnError);
if (NULL == pConnError){
/** Second step: try to get a connection to the given bus.*/
pProxy = gdbus_mcuinfo_proxy_new_sync (pConnection,
G_DBUS_PROXY_FLAGS_NONE,
busname, //AUTOLINK_GDBUS_BUS_NAME,
objpath, //AUTOLINK_GDBUS_BUS_OBJECT_PATH,
NULL,
&pProxyError);
if (0 == pProxy) {
ERR_LOG ("autolink_dbusclient_init: Failed to create proxy. Reason: %s.\n", pProxyError->message);
g_error_free (pProxyError);
pConnError = NULL;
bRet = FALSE;
}
}
else{
ERR_LOG ("autolink_dbusclient_init: Failed to connect to dbus. Reason: %s.\n", pConnError->message);
g_error_free (pConnError);
pConnError = NULL;
bRet = FALSE;
}
usleep (200*1000);
}while(FALSE == bRet);
if (TRUE == bRet) {
/** Third step: Attach to dbus signals */
register_client_sighandler (pProxy);
}
/* create dbus client thread */
ret = pthread_create (&tid_client,NULL,&dbus_client_thread,(void *)mainloop);
INFO_LOG ("create dbus client pthread %s.\n",(ret)?"fail":"success");
if (ret != 0) return ERR_THREAD;
pdbusclient->mainloop = mainloop;
pdbusclient->tid_client = tid_client;
pdbusclient->pProxy = pProxy;
return ERR_OK;
}
rtsp_error_t rtsp_phdr_transport(rtsp_header_t *header, const char *msg, int32_t msg_len, const char **endptr){
const char *scan = NULL;
const char *temp = NULL;
const char *scan_start = NULL;
const char *scan_end = NULL;
const char *end = msg + msg_len;
rtsp_error_t err = RTSP_E_FAILURE;
if(!header || !msg || msg_len <= 0){
return (RTSP_E_INVALID_ARG);
}
/* TODO - Multiple transport headers separated by comma.
*/
/*
* transport-protocol/profile
*/
scan = msg;
if(msg_len < STATIC_STR_LEN("RTP/AVP"))
return (RTSP_E_FAILURE);
if(0 != strncmp(scan, "RTP/AVP", STATIC_STR_LEN("RTP/AVP"))){
return (RTSP_E_FAILURE);
}
scan += STATIC_STR_LEN("RTP/AVP");
header->transport.spec = 0;
if(*scan == ';') {
header->transport.spec = TSPEC_RTP_AVP_UDP;
} else if(*scan == '/'){
if(((scan+STATIC_STR_LEN("/TCP"))<end )
&& (0 == strncasecmp(scan,"/TCP",STATIC_STR_LEN("/TCP")))){
header->transport.spec = TSPEC_RTP_AVP_TCP;
scan+=STATIC_STR_LEN("/TCP");
} else if(((scan+STATIC_STR_LEN("/UDP"))<end)
&& (0 == strncasecmp(scan,"/UDP",STATIC_STR_LEN("/UDP")))){
header->transport.spec = TSPEC_RTP_AVP_UDP;
scan+=STATIC_STR_LEN("/UDP");
}
}
while( (scan< end) && (*scan == ';')){
scan++;
scan_end = find_char(scan, end, ';');
if(*scan_end != ';')
scan_end = find_char(scan, end, '\r');
/*
* Quite a long function - TODO splitup
* Logic
* First char is the Key
* 1. Switch on key
* 2. Do strcmp and find match
* 3. Extract parameter values
*/
scan_start = scan;
switch (*scan|0x20){
case 'u':
err = is_strncasematch(scan, scan_end, "unicast", STATIC_STR_LEN("unicast"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("unicast");
header->transport.spec |= TSPEC_RTP_AVP_UNICAST;
break;
}
break;
case 'm':
err = is_strncasematch(scan, scan_end, "multicast", STATIC_STR_LEN("multicast"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("multicast");
header->transport.spec |= TSPEC_RTP_AVP_MULTICAST;
break;
}
err = is_strncasematch(scan, scan_end, "mode", STATIC_STR_LEN("mode"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("mode");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
/*
* TODO - Mode parsing - Now we bypass and mark it as success
* 1\#mode
*/
scan = scan_end;
break;
}
break;
case 'd':
err = is_strncasematch(scan, scan_end, "destination", STATIC_STR_LEN("destination"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("destination");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
{
int host_len = 0;
host_len = rtsp_get_valid_host_len(scan, (scan_end-scan));
if(host_len < RTSP_MAX_HOST_LEN){
strncpy(header->transport.destination, scan, host_len);
scan+=host_len;
break;
} else {
ERR_LOG("Invalid Destination host");
err = RTSP_E_FAILURE;
break;
}
}
}
break;
case 'i':
err = is_strncasematch(scan, scan_end, "interleaved", STATIC_STR_LEN("interleaved"));
if(err == RTSP_E_SUCCESS){
header->transport.spec |= TSPEC_RTP_AVP_INTERLEAVED;
scan+=STATIC_STR_LEN("interleaved");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
header->transport.ileaved_ch_fr = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 3){
ERR_LOG("1*3DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
if(*temp == '-'){
scan = ++temp;
header->transport.ileaved_ch_to = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 3){
ERR_LOG("1*3DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
} else {
header->transport.ileaved_ch_to = -1;
}
}
break;
case 'a':
err = is_strncasematch(scan, scan_end, "append", STATIC_STR_LEN("append"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("append");
header->transport.append = 1;
break;
}
break;
case 't':
err = is_strncasematch(scan, scan_end, "ttl", STATIC_STR_LEN("ttl"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("ttl");
if(*scan!='='){
err = (RTSP_E_FAILURE);
break;
}
temp = scan;
header->transport.ttl = strtoul(scan, (char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
scan = temp;
}
break;
case 'l':
err = is_strncasematch(scan, scan_end, "layers", STATIC_STR_LEN("layers"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("layers");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
temp = scan;
header->transport.layers = strtoull(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
}
break;
case 'p':
err = is_strncasematch(scan, scan_end, "port", STATIC_STR_LEN("port"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("port");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
temp = scan;
header->transport.port_fr = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
if(*temp == '-'){
scan = ++temp;
header->transport.port_to = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
} else {
header->transport.port_to = -1;
}
scan = temp;
}
break;
case 'c':
err = is_strncasematch(scan, scan_end, "client_port", STATIC_STR_LEN("client_port"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("client_port");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
temp = scan;
header->transport.client_port_fr = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
if(*temp == '-'){
scan = ++temp;
header->transport.client_port_to = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
} else {
header->transport.client_port_to = -1;
}
scan = temp;
}
break;
case 's':
err = is_strncasematch(scan, scan_end, "server_port", STATIC_STR_LEN("server_port"));
if(err == RTSP_E_SUCCESS){
scan+=STATIC_STR_LEN("server_port");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
temp = scan;
header->transport.server_port_fr = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
}
if(*temp == '-'){
scan = ++temp;
header->transport.server_port_to = strtoul(scan,(char **)&temp,10);
if(temp > (scan_end+1)){
ERR_LOG("Parsing Transport Error - Check Logic");
err = RTSP_E_FAILURE;
break;
}
if(temp-scan > 5){
ERR_LOG("1*5DIGIT spec not met");
err = RTSP_E_FAILURE;
break;
}
} else {
header->transport.server_port_to = -1;
}
scan = temp;
} else if (RTSP_E_SUCCESS == (err = is_strncasematch(scan, scan_end, "ssrc", STATIC_STR_LEN("ssrc")))){
scan+=STATIC_STR_LEN("ssrc");
if(*scan != '='){
err = (RTSP_E_FAILURE);
break;
}
scan++;
/*
* 8*8(HEX)
*/
if((scan+8) > scan_end){
err = (RTSP_E_FAILURE);
break;
}
temp = scan;
header->transport.ssrc = strtoull(scan, (char **)&temp, 16);
if((temp-scan) != 8){
ERR_LOG("8*8(HEX) Spec not met for ssrc");
err = (RTSP_E_FAILURE);
break;
}
scan = temp;
} else {
err = RTSP_E_UNSUPPORTED;
}
break;
default:
err = RTSP_E_UNSUPPORTED;
break;
}
if((err == RTSP_E_UNSUPPORTED) || (scan != scan_end)){
ERR_LOG("Parsing failed for Transport Parameter"\
"\"%.*s",(int )(scan_end - scan_start), scan_start);
}
if (err == RTSP_E_FAILURE){
break;
}
scan = scan_end;
/* Scan the next Parameter */
}
if(endptr)
*endptr = scan;
return (err);
}
int main(void)
{
int pid;
int rc;
int pfd[2];
int status = PTS_UNRESOLVED;
int s;
struct sched_param sp;
char buf[8];
/* Set up a pipe, for synching. */
rc = pipe(pfd);
if (rc) {
ERR_LOG("pipe", rc);
return status;
}
/* get in FIFO */
sp.sched_priority = sched_get_priority_min(SCHED_FIFO);
rc = sched_setscheduler(getpid(), SCHED_FIFO, &sp);
if (rc) {
ERR_LOG("sched_setscheduler", rc);
return status;
}
/* Must only use a single CPU */
rc = set_affinity(0);
if (rc) {
ERR_LOG("set_affinity", rc);
return status;
}
pid = fork();
if (pid == 0)
child_busy(pfd[1]);
if (pid < 0) {
ERR_LOG("fork", rc);
return status;
}
/* wait for child */
rc = read(pfd[0], buf, sizeof(buf));
if (rc != 2) {
kill(pid, SIGTERM);
waitpid(pid, NULL, 0);
ERR_LOG("read", rc);
return status;
}
/* Can only get here if sched_yield works. */
kill(pid, SIGTERM);
waitpid(pid, &s, 0);
status = PTS_PASS;
if (WIFSIGNALED(s)) {
s = WTERMSIG(s);
if (s != SIGTERM) {
printf("Failed: kill signal: %d, should be: %d\n",
s, SIGTERM);
status = PTS_FAIL;
}
} else if (WIFEXITED(s)) {
printf("Failed: child prematurely exited with: %d\n",
WEXITSTATUS(s));
status = PTS_FAIL;
}
if (status == PTS_PASS)
printf("Test PASSED\n");
return status;
}
static inline rtsp_error_t rtsp_parse_request_line(rtsp_start_line_t *p_start_line, const char *rtsp_msg_buffer, int32_t rtsp_msg_len, const char **endptr){
const char *parse_string = rtsp_msg_buffer;
const char *end = rtsp_msg_buffer + rtsp_msg_len;
const char *temp = NULL;
rtsp_error_t e_ret_val = RTSP_E_FAILURE;
if(!p_start_line || !rtsp_msg_buffer || rtsp_msg_len <= 0){
return (RTSP_E_INVALID_ARG);
}
/* R[6.1]
* Request-Line = Method SP Request-URI SP RTSP-Version CRLF
* Allowing multiple SP since RFC Text H[5.1] suggests
*/
e_ret_val = rtsp_get_method(&p_start_line->request.method, parse_string, rtsp_msg_len, &parse_string);
if(e_ret_val != RTSP_E_SUCCESS ){
return (e_ret_val);
}
/* Found valid Method Hence it is request line */
p_start_line->msg_type = RTSP_MSG_REQUEST;
/* SP */
temp = skip_SP(parse_string, end);
if((NULL == temp) || (temp==parse_string)){
/* No spaces */
e_ret_val = RTSP_E_FAILURE;
return(e_ret_val);
}else if(temp==end){
/* Only spaces till end */
e_ret_val = RTSP_E_INCOMPLETE;
return(e_ret_val);
}
parse_string = temp;
/* Request-URI */
e_ret_val = rtsp_get_url(&p_start_line->request.url ,parse_string, (rtsp_msg_len - (parse_string - rtsp_msg_buffer)), &parse_string);
if(e_ret_val != RTSP_E_SUCCESS){
ERR_LOG("Failed to parse URI");
return (e_ret_val);
}
/* SP */
temp = skip_SP(parse_string, end);
if((NULL == temp) || (temp==parse_string)){
/* No spaces */
e_ret_val = RTSP_E_FAILURE;
return(e_ret_val);
}else if(temp==end){
/* Only spaces till end */
e_ret_val = RTSP_E_INCOMPLETE;
return(e_ret_val);
}
parse_string = temp;
/* RTSP-Version */
e_ret_val = rtsp_get_version(&p_start_line->version, parse_string, (rtsp_msg_len - (parse_string - rtsp_msg_buffer)) , &parse_string);
if(e_ret_val != RTSP_E_SUCCESS){
return (e_ret_val);
}
/* CRLF */
if((parse_string+2) < end){
if((*parse_string++ == RTSP_CR) && (*parse_string++ == RTSP_LF)){
e_ret_val = RTSP_E_SUCCESS;
} else {
e_ret_val = RTSP_E_FAILURE;
}
} else {
e_ret_val = RTSP_E_INCOMPLETE;
}
if(endptr)
*endptr = parse_string;
return (e_ret_val);
}
