void test_CNamedPipeWrap_simple(IUnitTest* _ts) { //TEST_SUITE(_ts,); TEST_SUITE(_ts,_T("Pipe"),_T("CNamedPipeWrap class tests")); CNamedPipeWrap serverpipe; CNamedPipeWrap clientpipe; const LPCTSTR szPipeName = _T("test_pipe"); CEvent stopevnt(FALSE,TRUE); ok(serverpipe.create(szPipeName,stopevnt,PIPE_ACCESS_INBOUND,PIPE_READMODE_BYTE|PIPE_TYPE_BYTE,false),_T("server pipe create error")); ok(clientpipe.open(_T("."),szPipeName,GENERIC_WRITE,NMPWAIT_USE_DEFAULT_WAIT,PIPE_READMODE_BYTE,false),_T("client pipe open error")); bool bstoped = false; ok(serverpipe.connect(bstoped) && !bstoped,_T("server pipe connect error")); CString data(_T("0123456789")); string_converter<TCHAR,WCHAR> converted(data); DWORD dwMetaData = PDM_Data; ok(clientpipe.write_pipe((LPVOID)(LPCWSTR)converted,converted.get_length()*sizeof(WCHAR),dwMetaData),_T("client pipe write failed")); LPVOID pbuf = NULL; DWORD sz = 0; DWORD dwReadedMetaData = PDM_Null; ok(serverpipe.read_pipe(pbuf,sz,dwReadedMetaData,true),_T("server pipe read data failed")); ok(sz!=0,_T("server pipe read data failed (size == 0)")); ok(EQL(dwReadedMetaData,dwMetaData),_T("server pipe data differnt in meta type")); CString readed = string_converter<WCHAR,TCHAR>((WCHAR*)pbuf,sz/sizeof(WCHAR)); ok(!readed.Compare(data),_T("readed by server pipe data not equal to written by client pipe data")); delete[] trace_free(pbuf); pbuf = NULL; ok(clientpipe.write_pipe(pbuf,0,PDM_Data),_T("client pipe write error")); pbuf = NULL; sz = 0; dwReadedMetaData = PDM_Null; ok(serverpipe.read_pipe(pbuf,sz,dwReadedMetaData,true),_T("server pipe read data failed")); delete[] trace_free(pbuf); ok(serverpipe.disconnect(),_T("service pipe disconnect error")); clientpipe.close(); serverpipe.close(); }
int trace_enter(int fd, char *line, int closed) { struct trace *tmp; int res; assert(fd >= 0); if (trace_refs == NULL || fd >= trace_refsize) { res = trace_init(fd); if (res == -1) goto error; } if ((tmp = TAILQ_LAST(trace_refs[fd], traceq)) != NULL) { if (tmp->closed) trace_free(fd); } if ((tmp = malloc(sizeof(struct trace))) == NULL) goto error; tmp->line = line; tmp->closed = closed; TAILQ_INSERT_TAIL(trace_refs[fd], tmp, next); return (0); error: free(line); return (-1); }
void free() { m_dwMetaData = PDM_Null; if(NOT_NULL(m_pdata)) { delete trace_free(m_pdata); m_pdata = NULL; m_size = 0; } }
void amqpalloc_free(void* ptr) { if (!alloc_trace) { free(ptr); } else { trace_free(ptr); } }
void test_ServerThread(IUnitTest* _ts) { TEST_SUITE(_ts,_T("Pipe"),_T("Pipe Server thread")); //TRACE(_T("Test server thread ------------------------------------\n")); CServer1* pserver = trace_alloc(new CServer1(_T("test_pipe"))); pserver->start(); Sleep(100); CTime t1 = CTime::GetCurrentTime(); delete trace_free(pserver); CTime t2 = CTime::GetCurrentTime(); CTimeSpan dif = t2 - t1; ok(dif.GetSeconds()<5,_T("closing pipe server to long")); }
int main(int argc, char **argv) { if (argc < 2) { fprintf(stderr, "Usage: %s command [arguments ...]\n", argv[0]); exit(EXIT_FAILURE); } struct trace *trace = trace_new(process_new, NULL); int pid = trace_execvp(trace, &argv[1]); char buf[1024]; argv_join(buf, sizeof(buf), &argv[1], " "); fprintf(stderr, "[+] pid=%i, running: %s\n", pid, buf); while (trace_process_count(trace) > 0) { trace_read(trace); } trace_free(trace); return 0; }
// --- main -------------------------------------------------------------------- int mainloop (int argc, char *argv []) { FILE *fp = NULL; FILE *tempfp = NULL; sql_stmt_t *stmts = NULL; trace_t *t = NULL; bool_t only_q = FALSE; bool_t append = FALSE; bool_t only_r = FALSE; bool_t dbf_overwrite = FALSE; char *filename = NULL; char *folder = "."; char *dt = NULL; char *dt_filename = NULL; unsigned long partition_interval = PARTITION_INTERVAL_SECS; unsigned long partition_start = 0; int opt_idx = 0; int c = 0; int rc = 0; // command line option parsing struct option long_opts [] = { {"help", no_argument, NULL, 'h'}, {"version", no_argument, NULL, 'v'}, {"append", no_argument, NULL, 'a'}, {"show_schema", no_argument, NULL, 's'}, {"queries_only", no_argument, NULL, 'q'}, {"replies_only", no_argument, NULL, 'r'}, {"database", required_argument, NULL, 'd'}, {"db_overwrite", no_argument, NULL, 'o'}, {"interval", required_argument, NULL, 'i'}, {"db_folder", required_argument, NULL, 'f'}, { NULL, 0, NULL, 0 } }; while ((c = getopt_long (argc, argv, "hvasqrd:n:oi:f:", long_opts, &opt_idx)) != -1) { switch (c) { case 'v': fprintf (stdout, "%s\n", DNS2SQLITE_VERSION); // VERSION defined in dns2sqlite.h exit (0); break; case 's': fprintf (stdout, "%s\n", g_tabledefs); // VERSION defined in dns2sqlite.h exit (0); break; case 'a': append = TRUE; break; case 'q': only_q = TRUE; break; case 'r': only_r = TRUE; break; case 'd': filename = optarg; break; case 'o': dbf_overwrite = TRUE; break; case 'i': partition_interval = strtoul (optarg, NULL, NUM_BASE); partition_interval = (partition_interval < 1 ? 1 : partition_interval) * 60; break; case 'f': folder = optarg; break; default: fprintf (stderr, "Unknown option: %c\n", c); // FALL THRU case 'h': usage (argv [0]); return 0; } } argc -= optind; argv += optind; // handle dangling command line arguments // N.B. this does not work if a pipe and a file is used at the same time. // If files are given then they should be processed before the pipe is read // from stdin. That is, while argc > 0 open each file and go to the main // loop. When argc = 0 then open stdin and go to the main loop: // // while (argc > 0) { // fp = fopen (argv [argc -1], "r"); // if (fp == NULL) {return FAILURE} // else {read_file (fp, ...);} // fclose (fp); // argc--; // } // fp = stdin; switch (argc) { case 0: fp = stdin; break; case 1: fp = fopen (argv [argc -1], "r"); if (fp == NULL) { perror (argv [argc -1]); return 1; } break; default: usage (argv [0]); return 1; } if (filename == NULL) { fprintf (stderr, "Error: No database specified \n"); } // main loop // This should at least be moved into its own function. while ((t = parse_line (fp)) != NULL) { partition_start = p_start (partition_start, t->s, partition_interval); if ((unsigned long) t->s >= (partition_start + partition_interval)) { rc = commit ((stmts + COMMIT)->pstmt); close_db (G_DB); G_DB = NULL; rc = chdir (".."); if (rc == -1) { perror (NULL); return FAILURE; } partition_start += partition_interval; } // check if database is open if (!isdbopen (G_DB)) { // create directory name if (dt) XFREE(dt); dt = sec_to_datetime_str (partition_start); if (!dt) return FAILURE; // generate path if (dt_filename) XFREE(dt_filename); dt_filename = make_dt_filename (dt, filename); if (dt_filename == NULL) { XFREE(dt); return FAILURE; } // create directory if (make_db_dir (dt, folder) != SUCCESS) { XFREE(dt); XFREE(dt_filename); return FAILURE; } XFREE(dt); if (dbf_overwrite) { rc = unlink(dt_filename); if (rc==0) d2log (LOG_ERR|LOG_USER, "Unlinked file %s (due to overwrite flag).",dt_filename); else { rc = errno; if (rc != ENOENT) { d2log (LOG_ERR|LOG_USER, "Failed to unlink %s (overwrite) file code %d.",dt_filename,rc); XFREE(dt); XFREE(dt_filename); return FAILURE; } } } else { if (append == FALSE) { // simplistic test whether the database file exists tempfp = fopen (dt_filename, "r"); if (tempfp) { d2log (LOG_ERR|LOG_USER, "Error: Database file %s exists ! ( use -a to append or -o owerwrite ).",dt_filename); fclose (tempfp); return FAILURE; } } } if (!open_db (dt_filename, &G_DB, append)) { d2log (LOG_ERR|LOG_USER, "Failed to create new db %s.",dt_filename); XFREE(dt_filename); return FAILURE; } if (!prepare_stmts (G_DB, &stmts)) { d2log (LOG_ERR|LOG_USER, "Failed to prepare sql statements for db: %s.",dt_filename); close_db (G_DB); return FAILURE; } rc = start_transaction ((stmts + BEGIN_TRANS)->pstmt); } if (!store_to_db (G_DB, stmts, t, only_q, only_r)) { d2log (LOG_ERR|LOG_USER, "Failed to store data to db.\n"); } trace_free (t); } // clean up before exit fclose (fp); rc = commit ((stmts + COMMIT)->pstmt); close_db (G_DB); }
int main(int argc, char *argv[]) { bool need_exit = false; ptrace_context ptrace_ctx; program_params params; struct itimerval itv; struct proc_timer proc_time; calltree_node *root = NULL; g_progname = argv[0]; if (!parse_args(¶ms, argc, argv)) usage(); print_message("Reading symbols (list of function)"); init_fndescr(params.pid); if (params.just_print_symbols) { print_symbols(); free_fndescr(); exit(0); } if (!reset_process_time(&proc_time, params.pid, params.prof_method)) { free_fndescr(); errx(2, "Failed to retrieve process time"); } print_message("Attaching to process: %d", params.pid); memset(&ptrace_ctx, 0, sizeof(ptrace_ctx)); if (!trace_init(params.pid, &ptrace_ctx)) err(1, "Failed to initialize unwind internals"); signal(SIGCHLD, on_sigchld); if (ptrace(PTRACE_ATTACH, params.pid, 0, 0) == -1) { int saved_errno = errno; warn("ptrace(PTRACE_ATTACH) failed"); if (saved_errno == EPERM) { printf("You have to see NOTES section of `man crxprof' for workarounds.\n"); } exit(2); } if (do_wait(&ptrace_ctx, true) != WR_STOPPED) err(1, "Error occured while stopping the process"); if (ptrace(PTRACE_CONT, params.pid, 0, 0) < 0) err(1, "Error occured while stopping the process 2"); /* interval timer for snapshots */ itv.it_interval.tv_sec = 0; itv.it_interval.tv_usec = params.us_sleep; itv.it_value = itv.it_interval; signal(SIGALRM, on_sigalarm); if (setitimer(ITIMER_REAL, &itv, NULL) == -1) err(1, "setitimer failed"); print_message("Starting profile (interval %dms)", params.us_sleep / 1000); print_message("Press ^C once to show profile, twice to quit"); signal(SIGINT, on_sigint); /* drop first meter since it contains our preparations */ (void)get_process_dt(&proc_time); while(!need_exit) { waitres_t wres = WR_NOTHING; sleep(1); if (timer_alarmed) { uint64_t proc_dt = get_process_dt(&proc_time); bool need_prof = (params.prof_method == PROF_REALTIME); if (params.prof_method == PROF_CPUTIME) { char st = get_procstate(&ptrace_ctx); if (st == 'R') need_prof = true; } if (need_prof) { kill(params.pid, SIGSTOP); wres = do_wait(&ptrace_ctx, true); if (wres == WR_STOPPED) { int signo_cont = (ptrace_ctx.stop_signal == SIGSTOP) ? 0 : ptrace_ctx.stop_signal; if (!get_backtrace(&ptrace_ctx)) err(2, "failed to get backtrace of process"); /* continue tracee ASAP */ if (ptrace_verbose(PTRACE_CONT, params.pid, 0, signo_cont) < 0) err(1, "ptrace(PTRACE_CONT) failed"); ptrace_ctx.nsnaps++; if (fill_backtrace(proc_dt, &ptrace_ctx.stk, &root)) ptrace_ctx.nsnaps_accounted++; } } } if (wres != WR_FINISHED && wres != WR_NEED_DETACH) { wres = discard_wait(&ptrace_ctx); } if (sigint_caught_twice) { need_exit = true; } else if (sigint_caught || wres == WR_FINISHED || wres == WR_NEED_DETACH) { if (root) { print_message("%" PRIu64 " snapshot interrputs got (%" PRIu64 " dropped)", ptrace_ctx.nsnaps, ptrace_ctx.nsnaps - ptrace_ctx.nsnaps_accounted); visualize_profile(root, ¶ms.vprops); if (params.dumpfile) dump_profile(root, params.dumpfile); } else print_message("No symbolic snapshot caught yet!"); sigint_caught = false; } if (wres == WR_FINISHED || wres == WR_NEED_DETACH) { if (wres == WR_NEED_DETACH) (void)ptrace_verbose(PTRACE_DETACH, params.pid, 0, ptrace_ctx.stop_signal); need_exit = true; } } free_fndescr(); trace_free(&ptrace_ctx); if (root) calltree_destroy(root); return 0; }
int trace_read (const char *filename) { FILE *trace = fopen(filename, "r"); assert_inner(trace, "fopen"); void *trace_buf = NULL; unsigned long trace_bufsize = 0; size_t n = fread(&trace_bufsize, sizeof(unsigned long), 1, trace); assert_set_errno(ENOTSUP, n == 1, "fread"); trace_buf = malloc(trace_bufsize); assert_inner(trace_buf, "malloc"); n = fread(trace_buf, 1, trace_bufsize, trace); assert_set_errno(ENOTSUP, n == trace_bufsize, "fread"); assert_set_errno(ENOTSUP, feof(trace), "feof"); unsigned int trace_ended = 0; unsigned long trace_index = 0; while (trace_index < trace_bufsize) { char sign = *((char*)(trace_buf + trace_index)); trace_index += sizeof(char); switch (sign) { case 'e': trace_enter(trace_buf + trace_index); trace_index += 2 * sizeof(uintptr_t) + sizeof(unsigned long long); break; case 'x': trace_exit(trace_buf + trace_index); trace_index += sizeof(unsigned long long); break; case '+': trace_malloc(trace_buf + trace_index); trace_index += sizeof(size_t) + 2 * sizeof(uintptr_t) + sizeof(unsigned long long); break; case '*': trace_realloc(trace_buf + trace_index); trace_index += sizeof(size_t) + 3 * sizeof(uintptr_t) + sizeof(unsigned long long); break; case '-': trace_free(trace_buf + trace_index); trace_index += 2 * sizeof(uintptr_t) + sizeof(unsigned long long); break; case 'E': trace_end(trace_buf + trace_index); trace_index += sizeof(unsigned long long); trace_ended = 1; assert_set_errno(ENOTSUP, trace_bufsize == trace_index, "END not at end"); break; default: assert_set_errno(ENOTSUP, 0, "sign switch"); break; } } if (!trace_ended) assert_set_errno(ENOTSUP, 0, "no END at end"); free(trace_buf); fclose(trace); return 0; }
void test_CPipeReadBuffer(IUnitTest* _ts) { TEST_SUITE(_ts,_T("Pipe"),_T("buffer operations")); CPipeReadedBuffer buffer; CPipeReadedBuffer::PipeBufferErrorsEn bufferr = CPipeReadedBuffer::PBE_Success; ok(buffer.is_empty(),_T("created buffer is not empty")); const DWORD allocate_size = 100; const DWORD blksz_1 = 122; const DWORD blksz_1_aligned = align(blksz_1,QWORD()); const DWORD blksz_2 = 10; const DWORD blksz_2_aligned = align(blksz_2,QWORD()); const DWORD blksz_3 = 15; const DWORD blksz_3_aligned = align(blksz_3,QWORD()); LPVOID pbuf = NULL; pbuf = buffer.alloc_chunk(allocate_size); ok(is_all(pbuf,allocate_size,(BYTE)0),_T("alloc_chunk() not zeros memory")); ok(buffer.get_firstBlockRealSize()==0,_T("allocated chunk is not counted")); LPDWORD pdwbuf = (LPDWORD)pbuf; pdwbuf[0] = PDM_Data; pdwbuf[1] = blksz_1; ok(buffer.get_firstBlockRealSize()==allocate_size-sizeof(DWORD)*2,_T("bad real size")); ok(buffer.get_firstBlockSendedSize()==blksz_1,_T("allocated chunk is not counted")); ok(buffer.get_firstBlockMetaData()==PDM_Data,_T("no metadata DWORD in data chunk")); pbuf = buffer.alloc_chunk(allocate_size); fill_fortest((LPVOID)(pdwbuf+2),allocate_size-sizeof(DWORD)*2); DWORD cnt = blksz_1 - (allocate_size-sizeof(DWORD)*2); fill_fortest(pbuf,cnt,(byte)(blksz_1-cnt)); ok(buffer.get_firstBlockRealSize()==blksz_1,_T("not processed block after it was already readed")); ok(buffer.get_firstBlockSendedSize()==blksz_1,_T("bad real size")); pdwbuf = (LPDWORD) ((LPBYTE)pbuf + blksz_1_aligned - (allocate_size-sizeof(DWORD)*2)); pdwbuf[0] = PDM_Data; pdwbuf[1] = blksz_2; fill_fortest((LPVOID)(pdwbuf+2),blksz_2); pdwbuf = (LPDWORD)( (LPBYTE)pbuf + blksz_1_aligned - (allocate_size - sizeof(DWORD)*2) + sizeof(DWORD)*2 + blksz_2_aligned ); pdwbuf[0] = PDM_Data; pdwbuf[1] = blksz_3; fill_fortest((LPVOID)(pdwbuf+2),blksz_3); LPVOID preadbuf = NULL; DWORD dwsize = 0; DWORD dwMetaData = PDM_Null; ok(EQL(CPipeReadedBuffer::PBE_Success,buffer.read(preadbuf,dwsize,dwMetaData,true)) && EQL(dwMetaData,PDM_Data) ,_T("read error") ); ok(EQL(dwsize,blksz_1),_T("read error")); ok(test_filling(preadbuf,dwsize),_T("inccorrect data was readed")); ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size")); ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size")); delete[] trace_free(preadbuf); dwsize = blksz_2+2;//set incorrect size preadbuf = trace_alloc(new BYTE[dwsize]); //test errors dwMetaData = PDM_Null; ok(EQL(CPipeReadedBuffer::PBE_WrongBufferSize,buffer.read(preadbuf,dwsize,dwMetaData,false)) ,_T("read return not PBE_WrongBufferSize") ); ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size")); ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size")); dwMetaData = PDM_Null; ok(EQL(CPipeReadedBuffer::PBE_InvalidArg,buffer.read(preadbuf,dwsize,dwMetaData,true)) ,_T("read return not PBE_InvalidArg") ); ok(buffer.get_firstBlockRealSize()==blksz_2,_T("incorrect buffer size")); ok(buffer.get_firstBlockSendedSize()==blksz_2,_T("incorrect sended buffer size")); delete[] trace_free(preadbuf); dwsize = blksz_2; preadbuf = trace_alloc(new BYTE[dwsize]); ok(EQL(CPipeReadedBuffer::PBE_Success,buffer.read(preadbuf,dwsize,dwMetaData,false)) && EQL(dwMetaData,PDM_Data) ,_T("read return not PBE_Success") ); ok(test_filling(preadbuf,dwsize),_T("incorrect data was readed")); ok(EQL(buffer.get_firstBlockRealSize(),blksz_3),_T("incorrect real size")); ok(EQL(buffer.get_firstBlockSendedSize(),blksz_3),_T("incorrect sended size")); ok(EQL(buffer.free_firstBlock(),CPipeReadedBuffer::PBE_Success),_T("error while free first block")); ok(EQL(buffer.free_firstBlock(),CPipeReadedBuffer::PBE_DataNotReady),_T("free_firstBlock return not PBE_DataNotReady")); delete[] trace_free(preadbuf); }