int main(int argc, char *argv[])
{
unsigned int start = 0;
unsigned int total_iter = 0;
if (argc != 3)
usage(argv[0]);
if (argv[1])
start = (unsigned int)atoi(argv[1]);
else
usage(argv[0]);
if (argv[2])
total_iter = (unsigned int)atoi(argv[2]);
else
usage(argv[0]);
// Current sequence.
unsigned int *seq = NULL;
unsigned int seq_size = count_digits(start);
seq = malloc(seq_size * sizeof(unsigned int));
// Convert the starting number in a number sequence
int d = 0;
for(d = seq_size - 1; d >= 0;d--)
{
seq[d] = start % 10;
start /= 10;
}
// New sequence.
unsigned int *new_seq = NULL;
unsigned int new_seq_size = 0;
unsigned int i = 0;
for (i = 0;i<total_iter;i++)
{
update_seq(seq, seq_size, &new_seq, &new_seq_size);
if (i == total_iter - 1)
print_seq(new_seq, new_seq_size);
seq_size = new_seq_size;
new_seq_size = 0;
swap_ptr(&seq, &new_seq);
if (new_seq)
free(new_seq);
}
if (seq)
free(seq);
return 0;
}
// replace testName with the name of the particular test. Replace ClassName with
// the name of the class being tested
TEST(question1_test1, swap_ptr_test)
{
int n1=10,n2=20;
swap_ptr(&n1,&n2);
CHECK_EQUAL(20,n1);
CHECK_EQUAL(10,n2);
}
void output_buffer_call_back()
{
swap_ptr(&callback_str_buffer, &output_buffer);
if (output_buffer)
output_buffer[0] = 0;
output_bufferN = 0;
fake_shift();
}
void clear_output_buffer()
{
if (output_buffer)
output_buffer[0] = 0;
output_bufferN = 0;
swap_ptr(&output_buffer_raw, &output_buffer_raw_bak);
if (output_buffer_raw)
output_buffer_raw[0] = 0;
output_buffer_rawN = 0;
}
int main(){
int a = 1, b = 2;
std::cout << "a = " << a << ", b = " << b << "\n";
// swap values of a and b
swap_ptr(&a, &b);
// it worked!
std::cout << "addr( a) = " << &a << ", addr( b) = " << &b << "\n";
std::cout << "a = " << a << ", b = " << b << "\n";
return 1;
}
void
test_swap_ptr(void)
{
int ia = 5;
int ib = 3;
int *pa = &ia;
int *pb = &ib;
if (ia > ib)
{
swap_ptr(&pa, &pb);
}
}
int
main (int argc,
char *argv[])
{
int num1 = 10;
int num2 = 20;
int *ptr1 = &num1;
int *ptr2 = &num2;
printf ("Before : ptr1 -> %d, ptr2 -> %d \n", *ptr1, *ptr2);
swap_ptr (&ptr1, &ptr2);
printf ("Before : ptr1 -> %d, ptr2 -> %d \n", *ptr1, *ptr2);
return 0;
}
OMX_ERRORTYPE HantroOmx_bufferlist_reserve(BUFFERLIST* list, OMX_U32 newsize)
{
assert(list);
if (newsize < list->capacity)
return OMX_ErrorBadParameter;
BUFFER** data = (BUFFER**)OSAL_Malloc(sizeof(BUFFER**) * newsize);
if (!data)
return OMX_ErrorInsufficientResources;
memset(data, 0, sizeof(BUFFER*) * newsize);
memcpy(data, list->list, list->size * sizeof(BUFFER*));
swap_ptr(&data, &list->list);
list->capacity = newsize;
OSAL_Free(data);
return OMX_ErrorNone;
}
int empty_str_aft_null(char **tab)
{
int i;
int ok;
i = 0;
ok = 1;
while (tab[i] != NULL)
{
if (tab[i][0] == '\0')
{
swap_ptr((void**)(&(tab[i])), (void**)(&(tab[i + 1])));
if (tab[i] == NULL)
i--;
ok = 0;
}
i++;
}
return (ok);
}
void qsortRecursive(int *count, char **words, int low, int high)
{
int l = low;
int r = high;
int m = count[l + (r - l) / 2];
while (l <= r)
{
while (count[l] > m)
{
l++;
}
while (count[r] < m)
{
r--;
}
if (l <= r)
{
swap_int(&count[l], &count[r]);
swap_ptr(&words[l], &words[r]);
l++;
r--;
}
}
if (r > low)
{
qsortRecursive(count, words, low, r);
}
if (l < high)
{
qsortRecursive(count, words, l, high);
}
}
/** Move a client in tile grid with the mouse
*\param c Client double pointer
*/
static void
mouse_move_tile_client(Client **c)
{
Client *sc;
Window w;
int d;
if(!((*c)->flags & TileFlag) && !((*c)->flags & LMaxFlag))
return;
XQueryPointer(dpy, ROOT, &w, &w, &d, &d, &d, &d, (uint*)&d);
if(((sc = client_gb_win(w)) || (sc = client_gb_frame(w)) || (sc = client_gb_titlebar(w)))
&& (*c)->win != sc->win && !((*c)->flags & HideFlag) && !(sc->flags & HideFlag))
{
client_swap(sc, *c);
client_focus(sc);
swap_ptr((void**)c, (void**)&sc);
}
return;
}
/* this is the main function with the loops and modes */
void shoot(char *buf, int buff_size)
{
struct timespec sleep_ms_s, sleep_rem;
int ret, cseqtmp, rand_tmp;
char buf2[BUFSIZE], buf3[BUFSIZE], lport_str[LPORT_STR_LEN];
/* delays.retryAfter = DEFAULT_TIMEOUT; */
if (transport == SIP_UDP_TRANSPORT) {
delays.retryAfter = timer_t1;
}
else {
delays.retryAfter = timer_final;
}
inv_trans = 0;
cseq_counter = 1;
usrlocstep = REG_REP;
/* initalize local vars */
cdata.dontsend=cdata.dontrecv=counters.retrans_r_c=counters.retrans_s_c= 0;
delays.big_delay=counters.send_counter=counters.run= 0;
timers.delaytime.tv_sec = 0;
timers.delaytime.tv_usec = 0;
usern = NULL;
/* initialize local arrays */
memset(buf2, 0, BUFSIZE);
memset(buf3, 0, BUFSIZE);
memset(lport_str, 0, LPORT_STR_LEN);
cdata.csock = cdata.usock = -1;
cdata.connected = 0;
cdata.buf_tmp = NULL;
cdata.buf_tmp_size = 0;
memset(&(timers.sendtime), 0, sizeof(timers.sendtime));
memset(&(timers.recvtime), 0, sizeof(timers.recvtime));
memset(&(timers.firstsendt), 0, sizeof(timers.firstsendt));
memset(&(timers.starttime), 0, sizeof(timers.starttime));
memset(&(timers.delaytime), 0, sizeof(timers.delaytime));
req = buf;
rep = buf2;
rec = buf3;
create_sockets(&cdata);
if (sleep_ms != 0) {
if (sleep_ms == -2) {
rand_tmp = rand();
sleep_ms_s.tv_sec = rand_tmp / 1000;
sleep_ms_s.tv_nsec = (rand_tmp % 1000) * 1000000;
}
else {
sleep_ms_s.tv_sec = sleep_ms / 1000;
sleep_ms_s.tv_nsec = (sleep_ms % 1000) * 1000000;
}
}
if (replace_b == 1){
replace_string(req, "$dsthost$", domainname);
replace_string(req, "$srchost$", fqdn);
sprintf(lport_str, "%i", lport);
replace_string(req, "$port$", lport_str);
if (username)
replace_string(req, "$user$", username);
}
if (replace_str)
replace_strings(req, replace_str);
/* set all regular expression to simplfy the result code indetification */
regcomp(&(regexps.replyexp), "^SIP/[0-9]\\.[0-9] [1-6][0-9][0-9]",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.proexp), "^SIP/[0-9]\\.[0-9] 1[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.okexp), "^SIP/[0-9]\\.[0-9] 2[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.redexp), "^SIP/[0-9]\\.[0-9] 3[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.authexp), "^SIP/[0-9]\\.[0-9] 40[17] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.errexp), "^SIP/[0-9]\\.[0-9] 4[0-9][0-9] ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
regcomp(&(regexps.tmhexp), "^SIP/[0-9]\\.[0-9] 483 ",
REG_EXTENDED|REG_NOSUB|REG_ICASE);
if (username) {
if (nameend > 0) {
usern = str_alloc(strlen(username) + 12);
create_usern(usern, username, namebeg);
}
else {
if (*(username + strlen(username) - 1) != '@') {
usern = str_alloc(strlen(username) + 2);
create_usern(usern, username, -1);
}
else {
usern = username;
}
}
}
if (usrloc == 1||invite == 1||message == 1){
/* calculate the number of required steps and create initial mes */
if (usrloc == 1) {
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
usrlocstep=REG_REP;
}
else if (invite == 1) {
create_msg(REQ_INV, req, rep, usern, cseq_counter);
inv_trans = 1;
usrlocstep=INV_RECV;
}
else {
create_msg(REQ_MES, req, rep, usern, cseq_counter);
if (mes_body)
usrlocstep=MES_OK_RECV;
else
usrlocstep=MES_RECV;
}
}
else if (trace == 1){
/* for trace we need some spezial initis */
namebeg=0;
create_msg(REQ_OPT, req, NULL, usern, cseq_counter);
set_maxforw(req, namebeg);
}
else if (flood == 1){
if (nameend<=0) nameend=INT_MAX;
namebeg=1;
create_msg(REQ_FLOOD, req, NULL, usern, cseq_counter);
}
else if (randtrash == 1){
counters.randretrys=0;
namebeg=1;
create_msg(REQ_RAND, req, NULL, usern, cseq_counter);
nameend=(int)strlen(req);
if (trashchar == 1){
if (trashchar < nameend)
nameend=trashchar;
else
fprintf(stderr, "warning: number of trashed chars to big. setting to "
"request length\n");
}
trash_random(req);
}
else {
/* for none of the modes we also need some inits */
if (file_b == 0) {
namebeg=1;
create_msg(REQ_OPT, req, NULL, usern, cseq_counter);
}
else {
if (STRNCASECMP(req, INV_STR, INV_STR_LEN) == 0) {
inv_trans = 1;
}
if(via_ins == 1)
add_via(req);
}
/* delays.retryAfter = delays.retryAfter / 10; */
if(maxforw!=-1)
set_maxforw(req, maxforw);
}
cdata.connected = set_target(&(cdata.adr), address, rport, cdata.csock, cdata.connected);
/* here we go until someone decides to exit */
while(1) {
before_sending();
if (sleep_ms == -2) {
rand_tmp = rand();
sleep_ms_s.tv_sec = rand_tmp / 1000;
sleep_ms_s.tv_nsec = (rand_tmp % 1000) * 1000;
}
if (sleep_ms != 0) {
dbg("sleeping for %li s + %li ns\n", sleep_ms_s.tv_sec, sleep_ms_s.tv_nsec);
nanosleep(&sleep_ms_s, &sleep_rem);
}
send_message(req, &cdata, &counters, &timers);
/* in flood we are only interested in sending so skip the rest */
if (flood == 0) {
ret = recv_message(rec, BUFSIZE, inv_trans, &delays, &timers,
&counters, &cdata, ®exps);
if(ret > 0)
{
if (usrlocstep == INV_OK_RECV) {
swap_ptr(&rep, &req);
}
/* send ACK for non-provisional reply on INVITE */
if ((STRNCASECMP(req, "INVITE", 6)==0) &&
(regexec(&(regexps.replyexp), rec, 0, 0, 0) == REG_NOERROR) &&
(regexec(&(regexps.proexp), rec, 0, 0, 0) == REG_NOMATCH)) {
build_ack(req, rec, rep, ®exps);
cdata.dontsend = 0;
inv_trans = 0;
/* lets fire the ACK to the server */
send_message(rep, &cdata, &counters, &timers);
inv_trans = 1;
}
/* check for old CSeq => ignore retransmission */
cseqtmp = cseq(rec);
if ((0 < cseqtmp) && (cseqtmp < cseq_counter)) {
if (verbose>0) {
printf("ignoring retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend = 1;
continue;
}
else if (regexec(&(regexps.authexp), rec, 0, 0, 0) == REG_NOERROR) {
if (!username && !auth_username) {
if (timing > 0) {
timing--;
if (timing == 0) {
if (counters.run == 0) {
counters.run++;
}
printf("%.3f/%.3f/%.3f ms\n", delays.small_delay, delays.all_delay / counters.run, delays.big_delay);
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
counters.run++;
new_transaction(req, rep);
delays.retryAfter = timer_t1;
continue;
}
fprintf(stderr, "%s\nerror: received 40[17] but cannot "
"authentication without a username or auth username\n", rec);
log_message(req);
exit_code(2, __PRETTY_FUNCTION__, "missing username for authentication");
}
/* prevents a strange error */
regcomp(&(regexps.authexp), "^SIP/[0-9]\\.[0-9] 40[17] ", REG_EXTENDED|REG_NOSUB|REG_ICASE);
insert_auth(req, rec);
if (verbose > 2)
printf("\nreceived:\n%s\n", rec);
new_transaction(req, rep);
continue;
} /* if auth...*/
/* lets see if received a redirect */
if (redirects == 1 && regexec(&(regexps.redexp), rec, 0, 0, 0) == REG_NOERROR) {
handle_3xx(&(cdata.adr));
} /* if redircts... */
else if (trace == 1) {
trace_reply();
} /* if trace ... */
else if (usrloc == 1||invite == 1||message == 1) {
handle_usrloc();
}
else if (randtrash == 1) {
handle_randtrash();
}
else {
handle_default();
} /* redirect, auth, and modes */
} /* ret > 0 */
else if (ret == -1) { // we did not got anything back, send again
/* no re-transmission on reliable transports */
if (transport != SIP_UDP_TRANSPORT) {
cdata.dontsend = 1;
}
continue;
}
else if (ret == -2) { // we received non-matching ICMP
cdata.dontsend = 1;
continue;
}
else {
if (usrloc == 1) {
printf("failed\n");
}
perror("socket error");
exit_code(3, __PRETTY_FUNCTION__, "internal socket error");
}
} /* !flood */
else {
if (counters.send_counter == 1) {
memcpy(&(timers.firstsendt), &(timers.sendtime), sizeof(struct timeval));
}
if (namebeg==nameend) {
printf("flood end reached\n");
printf("it took %.3f ms seconds to send %i request.\n",
deltaT(&(timers.firstsendt), &(timers.sendtime)), namebeg);
printf("we sent %f requests per second.\n",
(namebeg/(deltaT(&(timers.firstsendt), &(timers.sendtime)))*1000));
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
namebeg++;
cseq_counter++;
create_msg(REQ_FLOOD, req, NULL, usern, cseq_counter);
}
} /* while 1 */
/* this should never happen any more... */
if (randtrash == 1) {
exit_code(0, __PRETTY_FUNCTION__, NULL);
}
printf("** give up retransmissioning....\n");
if (counters.retrans_r_c>0 && (verbose > 1)) {
printf("%i retransmissions received during test\n", counters.retrans_r_c);
}
if (counters.retrans_s_c>0 && (verbose > 1)) {
printf("sent %i retransmissions during test\n", counters.retrans_s_c);
}
exit_code(3, __PRETTY_FUNCTION__, "got outside of endless messaging loop");
}
/* takes care of replies in the usrloc mode */
void handle_usrloc()
{
char *crlf;
char ruri[11+12+20]; //FIXME: username length 20 should be dynamic
if (regexec(&(regexps.proexp), rec, 0, 0, 0) == REG_NOERROR) {
if (verbose > 2) {
print_message_line(rec);
printf("ignoring provisional response\n\n");
}
if (inv_trans) {
delays.retryAfter = timer_final;
}
else {
delays.retryAfter = timer_t2;
}
cdata.dontsend = 1;
}
else {
switch (usrlocstep) {
case REG_REP:
/* we have sent a register and look
at the response now */
if (regexec(&(regexps.okexp), rec, 0, 0, 0) == REG_NOERROR) {
if (verbose > 1) {
printf ("\tOK\n");
}
if (verbose > 2) {
printf("\n%s\n", rec);
}
}
else {
fprintf(stderr, "received:\n%s\nerror: didn't "
"received '200 OK' on register (see "
"above). aborting\n", rec);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "received non-2xx reply for REGISTER");
}
if (invite == 0 && message == 0) {
if (namebeg==nameend) {
if (verbose>0) {
printf("\nAll usrloc tests"
" completed successful.\nreceived"
" last message %.3f ms after first"
" request (test duration).\n",
deltaT(&(timers.firstsendt), &(timers.recvtime)));
}
if (delays.big_delay>0 && verbose>0) {
printf("biggest delay between "
"request and response was %.3f"
" ms\n", delays.big_delay);
}
if (counters.retrans_r_c>0 && verbose>0) {
printf("%i retransmission(s) received from server.\n",
counters.retrans_r_c);
}
if (counters.retrans_s_c>0 && verbose>0) {
printf("%i time(s) the timeout of "
"%i ms exceeded and request was"
" retransmitted.\n",
counters.retrans_s_c, delays.retryAfter);
if (counters.retrans_s_c > nagios_warn) {
log_message(req);
exit_code(4, __PRETTY_FUNCTION__, "#retransmissions above nagios warn level");
}
}
if (timing) {
printf("%.3f ms\n",
deltaT(&(timers.firstsendt), &(timers.recvtime)));
}
on_success(rec);
} /* namebeg == nameend */
/* lets see if we deceid to remove a
binding (case 6)*/
if ( ((float)rand()/RAND_MAX)*100 > rand_rem) {
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
}
else {
/* to prevent only removing of low
user numbers new random number*/
cseq_counter++;
create_usern(usern, username, ((float)rand()/RAND_MAX) * namebeg);
create_msg(REQ_REM, req, NULL, usern, cseq_counter);
usrlocstep=UNREG_REP;
}
} /* invite == 0 && message == 0 */
else if (invite == 1) {
cseq_counter++;
create_msg(REQ_INV, req, rep, usern, cseq_counter);
inv_trans = 1;
usrlocstep=INV_RECV;
}
else if (message == 1) {
cseq_counter++;
create_msg(REQ_MES, req, rep, usern, cseq_counter);
inv_trans = 0;
usrlocstep=MES_RECV;
}
break;
case INV_RECV:
/* see if we received our invite */
sprintf(ruri, "%s sip:%s", INV_STR, usern);
if (!STRNCASECMP(rec, ruri, strlen(ruri))) {
if (verbose > 1) {
printf("\t\treceived invite\n");
}
if (verbose > 2) {
printf("\n%s\n", rec);
}
cpy_vias(rec, rep);
cpy_rr(rec, rep, 0);
swap_ptr(&req, &rep);
usrlocstep=INV_OK_RECV;
inv_trans = 0;
}
else {
fprintf(stderr, "received:\n%s\nerror: did not "
"received the INVITE that was sent "
"(see above). aborting\n", rec);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "did not received our own INVITE request");
}
break;
case INV_OK_RECV:
/* did we received our ok ? */
if (STRNCASECMP(rec, INV_STR, INV_STR_LEN)==0) {
if (verbose>0) {
printf("ignoring INVITE retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend=1;
return;
}
if (regexec(&(regexps.okexp), rec, 0, 0, 0) == REG_NOERROR) {
if (verbose > 1) {
printf("\t200 OK received\n");
}
if (verbose > 2) {
printf("\n%s\n", rec);
}
/* ACK was send already earlier generically */
usrlocstep=INV_ACK_RECV;
cdata.dontsend=1;
}
else {
fprintf(stderr, "received:\n%s\nerror: did not "
"received the '200 OK' that was sent "
"as the reply on the INVITE (see "
"above). aborting\n", rec);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "did not received our own 200 reply");
}
break;
case INV_ACK_RECV:
/* did we received our ack */
if (STRNCASECMP(rec, SIP200_STR, SIP200_STR_LEN)==0) {
if (verbose>0) {
printf("ignoring 200 OK retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend=1;
return;
}
sprintf(ruri, "%s sip:sipsak_conf@", ACK_STR);
if (STRNCASECMP(rec, ruri, strlen(ruri))==0) {
if (verbose > 1) {
printf("\tACK received\n");
}
if (verbose > 2) {
printf("\n%s\n", rec);
}
if (verbose>0 && nameend>0) {
printf("usrloc for %s%i completed "
"successful\n", username, namebeg);
}
else if (verbose>0) {
printf("usrloc for %s completed successful\n", username);
}
if (namebeg==nameend) {
if (verbose>0) {
printf("\nAll usrloc tests completed "
"successful.\nreceived last message"
" %.3f ms after first request (test"
" duration).\n", deltaT(&(timers.firstsendt), &(timers.recvtime)));
}
if (delays.big_delay>0) {
printf("biggest delay between "
"request and response was %.3f"
" ms\n", delays.big_delay);
}
if (counters.retrans_r_c>0) {
printf("%i retransmission(s) received from server.\n",
counters.retrans_r_c);
}
if (counters.retrans_s_c>0) {
printf("%i time(s) the timeout of "
"%i ms exceeded and request was"
" retransmitted.\n",
counters.retrans_s_c, delays.retryAfter);
if (counters.retrans_s_c > nagios_warn) {
log_message(req);
exit_code(4, __PRETTY_FUNCTION__, "#retransmissions above nagios warn level");
}
}
on_success(rec);
} /* namebeg == nameend */
if (usrloc == 1) {
/* lets see if we deceid to remove a
binding (case 6)*/
if (((float)rand()/RAND_MAX) * 100 > rand_rem) {
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
usrlocstep=REG_REP;
}
else {
/* to prevent only removing of low
user numbers new random number*/
cseq_counter++;
create_usern(usern, username, ((float)rand()/RAND_MAX) * namebeg);
create_msg(REQ_REM, req, NULL, usern, cseq_counter);
usrlocstep=UNREG_REP;
}
} /* usrloc == 1 */
else {
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_INV, req, rep, usern, cseq_counter);
inv_trans = 1;
usrlocstep=INV_RECV;
}
} /* STRNCASECMP */
else {
fprintf(stderr, "received:\n%s\nerror: did not "
"received the 'ACK' that was sent "
"as the reply on the '200 OK' (see "
"above). aborting\n", rec);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "missing ACK that was send by myself");
}
break;
case MES_RECV:
/* we sent the message and look if its
forwarded to us */
sprintf(ruri, "%s sip:%s", MES_STR, usern);
if (!STRNCASECMP(rec, ruri, strlen(ruri))) {
if (verbose > 1) {
crlf=STRCASESTR(rec, "\r\n\r\n");
crlf=crlf+4;
printf(" received message\n '%s'\n", crlf);
}
if (verbose > 2) {
printf("\n%s\n", rec);
}
cpy_vias(rec, rep);
swap_ptr(&req, &rep);
usrlocstep=MES_OK_RECV;
}
else {
fprintf(stderr, "received:\n%s\nerror: did not "
"received the 'MESSAGE' that was sent "
"(see above). aborting\n", rec);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "did not received my own MESSAGE request");
}
break;
case MES_OK_RECV:
/* we sent our reply on the message and
look if this is also forwarded to us */
if (STRNCASECMP(rec, MES_STR, MES_STR_LEN)==0) {
if (verbose>0) {
printf("ignoring MESSAGE retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend=1;
return;
}
if (regexec(&(regexps.okexp), rec, 0, 0, 0) == REG_NOERROR) {
if (verbose > 1) {
printf(" reply received\n\n");
}
else if (verbose>0 && nameend>0) {
printf("usrloc for %s%i completed "
"successful\n", username, namebeg);
}
else if (verbose>0) {
printf("usrloc for %s completed successful\n", username);
}
if (namebeg==nameend) {
if (verbose>0) {
printf("\nAll usrloc tests completed "
"successful.\nreceived last message"
" %.3f ms after first request (test"
" duration).\n", deltaT(&(timers.firstsendt), &(timers.recvtime)));
}
if (delays.big_delay>0) {
printf("biggest delay between "
"request and response was %.3f"
" ms\n", delays.big_delay);
}
if (counters.retrans_r_c>0) {
printf("%i retransmission(s) "
"received from server.\n",
counters.retrans_r_c);
}
if (counters.retrans_s_c>0) {
printf("%i time(s) the timeout of "
"%i ms exceeded and request was"
" retransmitted.\n",
counters.retrans_s_c, delays.retryAfter);
if (counters.retrans_s_c > nagios_warn) {
log_message(req);
exit_code(4, __PRETTY_FUNCTION__, "#retransmissions above nagios warn level");
}
}
on_success(rec);
} /* namebeg == nameend */
if (usrloc == 1) {
/* lets see if we deceid to remove a
binding (case 6)*/
if (((float)rand()/RAND_MAX) * 100 > rand_rem) {
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
usrlocstep=REG_REP;
}
else {
/* to prevent only removing of low
user numbers new random number*/
cseq_counter++;
create_usern(usern, username, ((float)rand()/RAND_MAX) * namebeg);
create_msg(REQ_REM, req, NULL, usern, cseq_counter);
usrlocstep=UNREG_REP;
}
} /* usrloc == 1 */
else {
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_MES, req, NULL, usern, cseq_counter);
usrlocstep=MES_RECV;
}
} /* regexec */
else {
if (verbose>0) {
if (mes_body) {
fprintf(stderr, "received:\n%s\nerror: did"
" not received 200 for the "
"MESSAGE (see above)\n",
rec);
}
else {
fprintf(stderr, "received:\n%s\nerror: did"
" not received the '200 OK' "
"that was sent as the reply on"
" the MESSAGE (see above). "
"aborting\n", rec);
}
}
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "received non-2xx reply for MESSAGE request");
}
break;
case UNREG_REP:
if (STRNCASECMP(rec, MES_STR, MES_STR_LEN)==0) {
if (verbose>0) {
printf("ignoring MESSAGE retransmission\n");
}
counters.retrans_r_c++;
cdata.dontsend=1;
return;
}
if (regexec(&(regexps.okexp), rec, 0, 0, 0) == REG_NOERROR) {
if (verbose > 1) {
printf(" OK\n\n");
}
else if (verbose>0 && nameend>0) {
printf("Binding removal for %s%i "
"successful\n", username, namebeg);
}
else if (verbose>0) {
printf("Binding removal for %s successful\n", username);
}
namebeg++;
cseq_counter++;
create_usern(usern, username, namebeg);
create_msg(REQ_REG, req, NULL, usern, cseq_counter);
usrlocstep=REG_REP;
}
else {
fprintf(stderr, "received:\n%s\nerror: did not "
"received the expected 200 on the "
"remove bindings request for %s%i (see"
" above). aborting\n", rec, username,
namebeg);
log_message(req);
exit_code(1, __PRETTY_FUNCTION__, "received non-2xx reply for de-register request");
}
break;
default:
fprintf(stderr, "error: unknown step in usrloc\n");
exit_code(2, __PRETTY_FUNCTION__, "unknown step in usrloc");
break;
} /* switch */
} /* regexec proexp */
}
void
substitute(const char *text, struct list *variables, char *substitued)
{
APP_DEBUG_FNAME;
regex_t reg;
regmatch_t match;
char *regstr; // stored regexp '\$VAR'
size_t n;
size_t maxlength;
struct variable *v;
struct {
char *buff;
char *ptr;
} read, write;
#define subst_buff_check(size) \
if ((size) > CONF_SUBSTITUTION_MAXLENGTH) { \
ERR("substitution buffer overflow"); \
myabort(); \
}
subst_buff_check(strlen(text));
regstr = alloc_string_size(max_var_name_len(variables));
strcpy(regstr, "\\$");
read.buff = alloc_string_size(CONF_SUBSTITUTION_MAXLENGTH);
write.buff = alloc_string_size(CONF_SUBSTITUTION_MAXLENGTH);
strcpy(read.buff, text);
while (variables) {
v = variables->item;
maxlength = CONF_SUBSTITUTION_MAXLENGTH;
read.ptr = read.buff;
write.ptr = write.buff;
strcpy(regstr + 2, v->name);
compile_regex(®, regstr);
while (regexec(®, read.ptr, 1, &match, 0) == 0) {
// copy string before $VAR
n = min(match.rm_so, maxlength);
strncpy(write.ptr, read.ptr, n);
write.ptr[n] = '\0';
write.ptr += n;
read.ptr += match.rm_eo; // go after $VAR
maxlength -= n;
// copy $VAR substitution
n = min(strlen(v->substitution), maxlength);
subst_buff_check(n);
strncpy(write.ptr, v->substitution, n);
write.ptr[n] = '\0';
write.ptr += n;
maxlength -= n;
}
n = min(strlen(read.ptr), maxlength);
subst_buff_check(n);
strncpy(write.ptr, read.ptr, n);
write.ptr[n] = '\0';
swap_ptr((void **)&write.buff, (void **)&read.buff);
variables = variables->next;
}
DEBUG("substitued '%s' ~> '%s'", text, read.buff);
strcpy(substitued, read.buff);
free(read.buff);
free(write.buff);
}
