/**
*******************************************************************************
* @brief Send a signal registration message.
*
* @param transport IN transport
* @param reg IN true to register, false to unregister
* @param category IN category (required)
* @param method IN method (optional, NULL means none)
* @param token OUT message token
* @param lserror OUT set on error
*
* @retval true on success
* @retval false on failure
*******************************************************************************
*/
bool
_LSTransportSignalRegistration(_LSTransport *transport, bool reg, const char *category,
const char *method, LSMessageToken *token, LSError *lserror)
{
/*
* format:
*
* category + NUL
* method + NUL (if method is NULL, then we just have NUL)
*/
bool ret = true;
int category_len = strlen_safe(category) + 1;
int method_len = strlen_safe(method) + 1;
LOG_LS_TRACE("%s: category: %s, method: %s\n", __func__, category, method);
_LSTransportMessage *message = _LSTransportMessageNewRef(category_len + method_len);
if (reg)
{
_LSTransportMessageSetType(message, _LSTransportMessageTypeSignalRegister);
}
else
{
_LSTransportMessageSetType(message, _LSTransportMessageTypeSignalUnregister);
}
char *message_body = _LSTransportMessageGetBody(message);
LS_ASSERT(message_body != NULL);
memcpy(message_body, category, category_len);
message_body += category_len;
if (method_len == 1)
{
char nul = '\0';
memcpy(message_body, &nul, sizeof(nul));
}
else
{
memcpy(message_body, method, method_len);
}
LS_ASSERT(transport->hub != NULL);
if (!_LSTransportSendMessage(message, transport->hub, token, lserror))
{
ret = false;
}
_LSTransportMessageUnref(message);
return ret;
}
void test_strncat(){
int8_t tx[5];
int8_t rx[32];
int len;
printf("-----test strncat-----\n");
snprintf_safe(tx, 5, "%s", "bi");
snprintf_safe(rx, 32, "%s", "ngo 12345");
len = strlen_safe(tx);
printf("tx='%s' len=%d\n", tx, len);
strncat_safe((char*)tx, (char*)rx, 5);
len = strlen_safe(tx);
printf("tx='%s' len=%d %s\n", tx, len, (len == 4) ? "DONE" : "FAILED");
}
void test_strlen(){
struct s_test{
int8_t str[5];
int8_t a;
};
struct s_test test;
int i;
test.a = 2;
printf("-----test strlen-----\n");
for(i = 0; i < 5; i++) test.str[i] = i+1;
int len = strlen_safe(test.str);
printf("str len = %d %s\n",
len,
(len <= 5) ? "DONE" : "FAILED");
}
FILE *_popen_safe(const char *cmd, const char *type)
{
pid_t pid;
int pfd[2];
int rpipe = 0, wpipe = 0, i;
char **argv;
char *ptr;
char *cmdcpy;
if(cmd == NULL || cmd == "")
return(NULL);
if(type[0] != 'r' && type[0] != 'w')
return(NULL);
if ((cmdcpy = strdup(cmd)) == NULL)
return(NULL);
argv = NULL;
if( (ptr = strtok(cmdcpy, __SEC_POPEN_TOKEN)) == NULL)
{
free(cmdcpy);
return(NULL);
}
for(i = 0;; i++)
{
if( ( argv = (char **) realloc(argv, (i+1) * sizeof(char *)) ) == NULL)
{
free(cmdcpy);
return(NULL);
}
if( (*(argv+i) = (char *) malloc((strlen_safe(ptr)+1) * sizeof(char))) == NULL)
{
free(cmdcpy);
return(NULL);
}
strncpy_safe(argv[i], ptr, (strlen_safe(ptr)+1));
if( (ptr = strtok(NULL, __SEC_POPEN_TOKEN)) == NULL)
{
if( ( argv = (char **) realloc(argv, (i+2) * sizeof(char *))) == NULL)
{
free(cmdcpy);
return(NULL);
}
argv[i+1] = NULL;
break;
}
}
if(type[0] == 'r')
rpipe = 1;
else
wpipe = 1;
if (pipe(pfd) < 0)
{
free(cmdcpy);
return(NULL);
}
if((pid = fork()) < 0)
{
close(pfd[0]);
close(pfd[1]);
free(cmdcpy);
return(NULL);
}
if(pid == 0) // child
{
if((pid = fork()) < 0)
{
close(pfd[0]);
close(pfd[1]);
free(cmdcpy);
return(NULL);
}
if(pid > 0)
{
exit(0); // child nr. 1 exits
}
// child nr. 2
if(rpipe)
{
close(pfd[0]); // close reading end, we don't need it
if (pfd[1] != STDOUT_FILENO)
dup2(pfd[1], STDOUT_FILENO); // redirect stdout to writing end of pipe
dup2(STDOUT_FILENO, STDERR_FILENO);
}
else
{
close(pfd[1]); // close writing end, we don't need it
if (pfd[0] != STDIN_FILENO)
dup2(pfd[0], STDIN_FILENO); // redirect stdin to reading end of pipe
}
if(strchr(argv[0], '/') == NULL)
execvp(argv[0], argv); // search in $PATH
else
execv(argv[0], argv);
close(pfd[0]);
close(pfd[1]);
free(cmdcpy);
return(NULL); // exec failed.. ooops!
}
else // parent
{
waitpid(pid, NULL, 0); // wait for child nr. 1
if(rpipe)
{
close(pfd[1]);
free(cmdcpy);
return(fdopen(pfd[0], "r"));
}
else
{
close(pfd[0]);
free(cmdcpy);
return(fdopen(pfd[1], "w"));
}
}
}
