int VWindowGUI::keypress_event() { int result = 0; switch(get_keypress()) { case 'w': case 'W': close_event(); result = 1; break; case 'z': mwindow->undo_entry(this); break; case 'Z': mwindow->redo_entry(this); break; case 'f': unlock_window(); if(mwindow->session->vwindow_fullscreen) canvas->stop_fullscreen(); else canvas->start_fullscreen(); lock_window("VWindowGUI::keypress_event 1"); break; case ESC: unlock_window(); if(mwindow->session->vwindow_fullscreen) canvas->stop_fullscreen(); lock_window("VWindowGUI::keypress_event 2"); break; } if(!result) result = transport->keypress_event(); return result; }
void sigio_handler(int signum, siginfo_t *info, void *uc) { int fd = info->si_fd; long band = info->si_band; int code = info->si_code; int i; if (code & SI_KERNEL) { /* We overflowed the RT signal queue and the kernel */ /* has rudely let us know w/o telling us which event */ /* Close a random event in hopes of stopping */ if (!logging) printf("SIGIO due to RT queue overflow\n"); /* Close all events? */ /* Extreme, but easier to re-play */ /* Does make for non-deterministic traces :( */ for(i=0;i<NUM_EVENTS;i++) { if (event_data[i].active) close_event(i,1); } } else { printf("SIGIO from fd %d band %lx code %d\n",fd,band,code); } stats.sigios++; }
int RecordMonitorGUI::keypress_event() { int result = 0; switch(get_keypress()) { case LEFT: if( !ctrl_down() ) { record->record_gui->set_translation(--(record->video_x), record->video_y, record->video_zoom); } else { record->video_zoom -= 0.1; record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom); } result = 1; break; case RIGHT: if( !ctrl_down() ) { record->record_gui->set_translation(++(record->video_x), record->video_y, record->video_zoom); } else { record->video_zoom += 0.1; record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom); } result = 1; break; case UP: if( !ctrl_down() ) { record->record_gui->set_translation(record->video_x, --(record->video_y), record->video_zoom); } else { record->video_zoom -= 0.1; record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom); } result = 1; break; case DOWN: if( !ctrl_down() ) { record->record_gui->set_translation(record->video_x, ++(record->video_y), record->video_zoom); } else { record->video_zoom += 0.1; record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom); } result = 1; break; case 'w': close_event(); break; default: if(canvas) result = canvas->keypress_event(this); if(!result && avc1394_transport) result = avc1394_transport->keypress_event(get_keypress()); break; } return result; }
int GWindowGUI::keypress_event() { switch(get_keypress()) { case 'w': case 'W': if(ctrl_down()) { close_event(); return 1; } break; } return 0; }
int am_net_close(am_net_t *n) { if (n == NULL) { return AM_EINVAL; } #ifdef _WIN32 WaitForSingleObject(n->pw, INFINITE); CloseHandle(n->pw); DeleteCriticalSection(&n->lk); #else pthread_join(n->pw, NULL); pthread_mutex_destroy(&n->lk); #endif /* close ssl/socket */ am_net_diconnect(n); /* shut down connected/disconnected events */ close_event(n->ce); close_exit_event(n->de); /* shut down response timeout handler */ am_close_timer_event(n->tm); n->tm = NULL; if (n->ra != NULL) { freeaddrinfo(n->ra); } n->ra = NULL; AM_FREE(n->hs, n->hp, n->req_headers); n->hs = NULL; n->hp = NULL; n->req_headers = NULL; return AM_SUCCESS; }
int main(int argc, char **argv) { FILE *logfile; char *logfile_name=NULL; char line[BUFSIZ]; char *result; long long total_syscalls=0,replay_syscalls=0; long long skip_lines=0; int i; int replay_which=REPLAY_ALL; if (argc<2) { print_usage(argv[0]); exit(1); } i=1; while(1) { if (i>=argc) break; if (argv[i][0]=='-') { switch(argv[i][1]) { case 'h': print_usage(argv[0]); exit(1); break; default: fprintf(stderr,"Unknown option -%c\n",argv[i][1]); exit(1); break; } } else { logfile_name=strdup(argv[i]); i++; } } if (logfile_name==NULL) { fprintf(stderr,"Must specify logfile name\n"); exit(1); } logfile=fopen(logfile_name,"r"); if (logfile==NULL) { fprintf(stderr,"Error opening %s\n",logfile_name); exit(1); } /* Init structs */ for(i=0;i<MAX_EVENTS;i++) { event_info[i].opened=0; event_info[i].enabled=0; mmap_info[i].valid=0; } /* Main loop */ while(1) { result=fgets(line,BUFSIZ,logfile); if (result==NULL) break; line_num++; if (line_num<skip_lines) continue; switch(line[0]) { case 'C': if (replay_which & REPLAY_CLOSE) { close_event(line); replay_syscalls++; } break; case 'F': if (replay_which & REPLAY_FORK) { fork_event(line); replay_syscalls++; } break; case 'G': sscanf(line,"%*c %d",&original_pid); printf("Original pid was %d\n",original_pid); break; case 'I': if (replay_which & REPLAY_IOCTL) { ioctl_event(line); replay_syscalls++; } break; case 'M': if (replay_which & REPLAY_MMAP) { mmap_event(line); replay_syscalls++; } break; case 'O': if (replay_which & REPLAY_OPEN) { open_event(line); replay_syscalls++; } break; case 'o': if (replay_which & REPLAY_OVERFLOW) { setup_overflow(line); replay_syscalls++; } break; case 'P': if (replay_which & REPLAY_PRCTL) { prctl_event(line); replay_syscalls++; } break; case 'p': if (replay_which & REPLAY_POLL) { poll_event(line); replay_syscalls++; } break; case 'Q': if (replay_which & REPLAY_TRASH_MMAP) { trash_mmap_event(line); replay_syscalls++; } break; case 'q': fprintf(stderr,"Quitting early\n"); exit(1); case 'R': if (replay_which & REPLAY_READ) { read_event(line); replay_syscalls++; } break; case 'S': if (replay_which & REPLAY_SEED) { /* don't need to do anything */ /* as we don't use rand */ } break; case 'U': if (replay_which & REPLAY_MUNMAP) { munmap_event(line); replay_syscalls++; } break; default: fprintf(stderr,"Line %lld Unknown log type \'%c\'\n", line_num,line[0]); break; } //if (error) break; total_syscalls++; if (total_syscalls%1000==0) { printf("%lld\n",total_syscalls); } } printf("ACTIVE EVENT REPORT\n"); printf("~~~~~~~~~~~~~~~~~~~\n"); printf("\tReplayed %lld of %lld syscalls\n", replay_syscalls,total_syscalls); int total_active=0,total_opened=0; for(i=0;i<MAX_EVENTS;i++) { if (event_info[i].opened) total_opened++; if (event_info[i].enabled) total_active++; } printf("\t%d events open, %d events active\n", total_opened,total_active); printf("ENABLED EVENTS\n\n"); for(i=0;i<MAX_EVENTS;i++) { if (event_info[i].enabled) { perf_pretty_print_event(stdout, i,original_pid, &event_info[i].attr, event_info[i].pid, event_info[i].cpu, event_info[i].group_fd, event_info[i].flags); printf("\n\n"); } } printf("SHORT EVENT SUMMARY\n\n"); for(i=0;i<MAX_EVENTS;i++) { if (event_info[i].enabled) { perf_pretty_print_event_short(stdout, i,original_pid, &event_info[i].attr, event_info[i].pid, event_info[i].cpu, event_info[i].group_fd, event_info[i].flags); } } return 0; }
/* * Open a file descriptor for perf events with `event_name', mmap it, and set * things up so that the calling thread receives SIGIO signals from it. * * Returns the perf_event_handle on success, else folly::none. */ folly::Optional<perf_event_handle> enable_event(const char* event_name, uint64_t sample_freq) { struct perf_event_attr attr = {}; pfm_perf_encode_arg_t arg = {}; arg.attr = &attr; arg.size = sizeof(arg); // Populate the `type', `config', and `exclude_*' members on `attr'. auto const pfmr = pfm_get_os_event_encoding(event_name, PFM_PLM3, PFM_OS_PERF_EVENT, &arg); if (pfmr != PFM_SUCCESS) { Logger::Warning("perf_event: failed to get encoding for %s: %s", event_name, pfm_strerror(pfmr)); return folly::none; } // Finish setting up `attr' and open the event. attr.size = sizeof(attr); attr.disabled = 1; attr.sample_freq = sample_freq; attr.freq = 1; attr.watermark = 0; attr.wakeup_events = 1; attr.precise_ip = 2; // request zero skid attr.sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID | PERF_SAMPLE_ADDR | PERF_SAMPLE_CALLCHAIN ; auto const ret = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0); if (ret < 0) { // Some machines might not have PEBS support (needed for precise_ip > 0), // but then PERF_SAMPLE_ADDR will always return zeros instead of the target // memory address. Just fail silently in this case. Logger::Verbose("perf_event: perf_event_open failed with: %s", folly::errnoStr(errno).c_str()); return folly::none; } auto const fd = safe_cast<int>(ret); // Recent versions of Linux have a CLOEXEC flag for perf_event_open(), but // use fcntl() for portability. Note that since we do this after we open the // event, this could in theory race with an exec() from another thread---but // that shouldn't be happening anyway. fcntl(fd, F_SETFD, O_CLOEXEC); // Make sure that any SIGIO sent from `fd' is handled by the calling thread. f_owner_ex owner; owner.type = F_OWNER_TID; owner.pid = syscall(__NR_gettid); // Set up `fd' to send SIGIO with sigaction info. if (fcntl(fd, F_SETFL, O_ASYNC) < 0 || fcntl(fd, F_SETSIG, SIGIO) < 0 || fcntl(fd, F_SETOWN_EX, &owner) < 0) { Logger::Warning("perf_event: failed to set up asynchronous I/O: %s", folly::errnoStr(errno).c_str()); close(fd); return folly::none; } // Map the ring buffer for our samples. auto const base = mmap(nullptr, mmap_sz(), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (base == MAP_FAILED) { Logger::Warning("perf_event: failed to mmap perf_event: %s", folly::errnoStr(errno).c_str()); close(fd); return folly::none; } auto const meta = reinterpret_cast<struct perf_event_mmap_page*>(base); auto const pe = perf_event_handle { fd, meta }; // Reset the event. This seems to be present in most examples, but it's // unclear if it's necessary or just good hygeine. (It's possible that it's // necessary on successive opens.) if (ioctl(fd, PERF_EVENT_IOC_RESET, 0) < 0) { Logger::Warning("perf_event: failed to reset perf_event: %s", folly::errnoStr(errno).c_str()); close_event(pe); return folly::none; } // Enable the event. The man page and other examples of usage all suggest // that the right thing to do is to start with the event disabled and then // enable it manually afterwards, so we do the same here even though it seems // strange and circuitous. if (ioctl(fd, PERF_EVENT_IOC_ENABLE, 0) < 0) { Logger::Warning("perf_event: failed to enable perf_event: %s", folly::errnoStr(errno).c_str()); close_event(pe); return folly::none; } return pe; }
int am_agent_policy_request(unsigned long instance_id, const char *openam, const char *token, const char *user_token, const char *req_url, const char *notif_url, const char *scope, const char *cip, const char *pattr, const char *server_id, struct am_ssl_options *info, struct am_namevalue **session_list, struct am_policy_result **policy_list) { static const char *thisfunc = "am_agent_policy_request():"; char *post = NULL, *post_data = NULL; am_net_t n; size_t post_sz; int status = AM_ERROR; int session_status = AM_SUCCESS; struct request_data req_data; if (!ISVALID(token) || !ISVALID(user_token) || !ISVALID(notif_url) || !ISVALID(scope) || !ISVALID(req_url) || !ISVALID(openam) || !ISVALID(cip)) { return AM_EINVAL; } memset(&req_data, 0, sizeof(struct request_data)); memset(&n, 0, sizeof(am_net_t)); n.instance_id = instance_id; n.timeout = AM_NET_CONNECT_TIMEOUT; n.url = openam; if (info != NULL) { memcpy(&n.ssl.info, info, sizeof(struct am_ssl_options)); } if (ISVALID(server_id)) { am_asprintf(&n.req_headers, "Cookie: amlbcookie=%s\r\n", server_id); } req_data.event = create_event(); if (req_data.event == NULL) { return AM_ENOMEM; } n.data = &req_data; n.on_connected = on_connected_cb; n.on_close = on_close_cb; n.on_data = on_agent_request_data_cb; n.on_complete = on_complete_cb; if (am_net_connect(&n) == 0) { char *token_in = NULL; size_t token_sz = am_asprintf(&token_in, "token:%s", token); char *token_b64 = base64_encode(token_in, &token_sz); size_t post_data_sz = am_asprintf(&post_data, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "<RequestSet vers=\"1.0\" svcid=\"Session\" reqid=\"0\">" "<Request><![CDATA[" "<SessionRequest vers=\"1.0\" reqid=\"1\" requester=\"%s\">" "<GetSession reset=\"true\">" /* reset the idle timeout */ "<SessionID>%s</SessionID>" "</GetSession>" "</SessionRequest>]]>" "</Request>" "<Request><![CDATA[" "<SessionRequest vers=\"1.0\" reqid=\"2\" requester=\"%s\">" "<AddSessionListener>" "<URL>%s</URL>" "<SessionID>%s</SessionID>" "</AddSessionListener>" "</SessionRequest>]]>" "</Request>" "</RequestSet>", NOTNULL(token_b64), user_token, NOTNULL(token_b64), notif_url, user_token); AM_FREE(token_in, token_b64); if (post_data != NULL) { post_sz = am_asprintf(&post, "POST %s/sessionservice HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/xml\r\n" "Connection: Keep-Alive\r\n" "Content-Type: text/xml; charset=UTF-8\r\n" "%s" "Content-Length: %d\r\n\r\n" "%s", n.uv.path, n.uv.host, n.uv.port, NOTNULL(n.req_headers), post_data_sz, post_data); if (post != NULL) { AM_LOG_DEBUG(instance_id, "%s sending request:\n%s", thisfunc, post); status = am_net_write(&n, post, post_sz); free(post); post = NULL; } free(post_data); post_data = NULL; } if (status == AM_SUCCESS) { wait_for_event(req_data.event, 0); } AM_LOG_DEBUG(instance_id, "%s response status code: %d", thisfunc, n.http_status); if (status == AM_SUCCESS && n.http_status == 200 && ISVALID(req_data.data)) { size_t req_url_sz = strlen(req_url); char *req_url_escaped = malloc(req_url_sz * 6 + 1); /* worst case */ if (req_url_escaped != NULL) { memcpy(req_url_escaped, req_url, req_url_sz); xml_entity_escape(req_url_escaped, req_url_sz); } AM_LOG_DEBUG(instance_id, "%s response:\n%s", thisfunc, req_data.data); if (strstr(req_data.data, "<Exception>") != NULL && strstr(req_data.data, "Invalid session ID") != NULL) { session_status = AM_INVALID_SESSION; } if (strstr(req_data.data, "<Exception>") != NULL && strstr(req_data.data, "Application token passed in") != NULL) { session_status = AM_INVALID_AGENT_SESSION; } if (session_status == AM_SUCCESS && session_list != NULL) { *session_list = am_parse_session_xml(instance_id, req_data.data, req_data.data_size); } req_data.data_size = 0; free(req_data.data); req_data.data = NULL; /* TODO: * <AttributeValuePair><Attribute name=\"requestDnsName\"/><Value>%s</Value></AttributeValuePair> */ post_data_sz = am_asprintf(&post_data, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "<RequestSet vers=\"1.0\" svcid=\"Policy\" reqid=\"3\">" "<Request><![CDATA[<PolicyService version=\"1.0\">" "<PolicyRequest requestId=\"4\" appSSOToken=\"%s\">" "<GetResourceResults userSSOToken=\"%s\" serviceName=\"iPlanetAMWebAgentService\" resourceName=\"%s\" resourceScope=\"%s\">" "<EnvParameters><AttributeValuePair><Attribute name=\"requestIp\"/><Value>%s</Value></AttributeValuePair></EnvParameters>" "<GetResponseDecisions>" "%s" "</GetResponseDecisions>" "</GetResourceResults>" "</PolicyRequest>" "</PolicyService>]]>" "</Request>" "</RequestSet>", token, user_token, NOTNULL(req_url_escaped), scope, cip, NOTNULL(pattr)); am_free(req_url_escaped); post_sz = am_asprintf(&post, "POST %s/policyservice HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/xml\r\n" "Content-Type: text/xml; charset=UTF-8\r\n" "Content-Length: %d\r\n" "%s" "Connection: close\r\n\r\n" "%s", n.uv.path, n.uv.host, n.uv.port, post_data_sz, NOTNULL(n.req_headers), post_data); if (post != NULL) { AM_LOG_DEBUG(instance_id, "%s sending request:\n%s", thisfunc, post); status = am_net_write(&n, post, post_sz); free(post); } } else { status = n.error != AM_SUCCESS ? n.error : AM_ERROR; } } if (status == AM_SUCCESS) { wait_for_event(req_data.event, 0); } else { AM_LOG_DEBUG(instance_id, "%s disconnecting", thisfunc); am_net_diconnect(&n); } AM_LOG_DEBUG(instance_id, "%s response status code: %d", thisfunc, n.http_status); if (status == AM_SUCCESS && n.http_status == 200 && ISVALID(req_data.data)) { AM_LOG_DEBUG(instance_id, "%s response:\n%s", thisfunc, req_data.data); if (strstr(req_data.data, "<Exception>") != NULL) { if (strstr(req_data.data, "SSO token is invalid") != NULL) { session_status = AM_INVALID_SESSION; } else if (strstr(req_data.data, "Application sso token is invalid") != NULL) { session_status = AM_INVALID_AGENT_SESSION; } } if (session_status == AM_SUCCESS && policy_list != NULL) { *policy_list = am_parse_policy_xml(instance_id, req_data.data, req_data.data_size, am_scope_to_num(scope)); } } am_net_close(&n); close_event(req_data.event); am_free(req_data.data); return session_status != AM_SUCCESS ? session_status : status; }
int am_agent_session_request(unsigned long instance_id, const char *openam, const char *token, const char *user_token, const char *notif_url) { char *post = NULL, *post_data = NULL; am_net_t n; size_t post_sz; int status = AM_ERROR; struct request_data ld; if (!ISVALID(token) || !ISVALID(user_token) || !ISVALID(openam) || !ISVALID(notif_url)) return AM_EINVAL; memset(&ld, 0, sizeof(struct request_data)); memset(&n, 0, sizeof(am_net_t)); n.instance_id = instance_id; n.timeout = AM_NET_CONNECT_TIMEOUT; n.url = openam; ld.event = create_event(); if (ld.event == NULL) return AM_ENOMEM; n.data = &ld; n.on_connected = on_connected_cb; n.on_close = on_close_cb; n.on_data = on_agent_request_data_cb; n.on_complete = on_complete_cb; if (am_net_connect(&n) == 0) { char *token_in = NULL; size_t token_sz = am_asprintf(&token_in, "token:%s", token); char *token_b64 = base64_encode(token_in, &token_sz); size_t post_data_sz = am_asprintf(&post_data, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "<RequestSet vers=\"1.0\" svcid=\"Session\" reqid=\"0\">" "<Request><![CDATA[" "<SessionRequest vers=\"1.0\" reqid=\"1\" requester=\"%s\">" "<GetSession reset=\"true\">" "<SessionID>%s</SessionID>" "</GetSession>" "</SessionRequest>]]>" "</Request>" "<Request><![CDATA[" "<SessionRequest vers=\"1.0\" reqid=\"2\" requester=\"%s\">" "<AddSessionListener>" "<URL>%s</URL>" "<SessionID>%s</SessionID>" "</AddSessionListener>" "</SessionRequest>]]>" "</Request>" "</RequestSet>", NOTNULL(token_b64), user_token, NOTNULL(token_b64), notif_url, user_token); AM_FREE(token_in, token_b64); if (post_data != NULL) { post_sz = am_asprintf(&post, "POST %s/sessionservice HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/xml\r\n" "Connection: close\r\n" "Content-Type: text/xml; charset=UTF-8\r\n" "Content-Length: %d\r\n\r\n" "%s", n.uv.path, n.uv.host, n.uv.port, post_data_sz, post_data); if (post != NULL) { status = am_net_write(&n, post, post_sz); free(post); post = NULL; } free(post_data); post_data = NULL; } } if (status == AM_SUCCESS) { wait_for_event(ld.event, 0); } else { am_net_diconnect(&n); } am_net_close(&n); close_event(ld.event); am_free(ld.data); return status; }
int am_agent_logout(unsigned long instance_id, const char *openam, const char *token, const char *server_id, struct am_ssl_options *info, void(*log)(const char *, ...)) { static const char *thisfunc = "am_agent_logout():"; am_net_t conn; int status = AM_ERROR; size_t post_sz, post_data_sz; char *post = NULL, *post_data = NULL; struct request_data req_data; if (!ISVALID(token) || !ISVALID(openam)) return AM_EINVAL; memset(&req_data, 0, sizeof(struct request_data)); memset(&conn, 0, sizeof(am_net_t)); conn.log = log; conn.instance_id = instance_id; conn.timeout = AM_NET_CONNECT_TIMEOUT; conn.url = openam; if (info != NULL) { memcpy(&conn.ssl.info, info, sizeof(struct am_ssl_options)); } if (ISVALID(server_id)) { am_asprintf(&conn.req_headers, "Cookie: amlbcookie=%s\r\n", server_id); } req_data.event = create_event(); if (req_data.event == NULL) return AM_ENOMEM; conn.data = &req_data; conn.on_connected = on_connected_cb; conn.on_close = on_close_cb; conn.on_data = on_agent_request_data_cb; conn.on_complete = on_complete_cb; if (am_net_connect(&conn) == 0) { post_data_sz = am_asprintf(&post_data, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "<RequestSet vers=\"1.0\" svcid=\"auth\" reqid=\"0\">" "<Request><![CDATA[" "<?xml version=\"1.0\" encoding=\"UTF-8\"?><AuthContext version=\"1.0\">" "<Request authIdentifier=\"%s\">" "<Logout/></Request></AuthContext>]]>" "</Request></RequestSet>", token); if (post_data != NULL) { post_sz = am_asprintf(&post, "POST %s/authservice HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/xml\r\n" "Connection: Close\r\n" "Content-Type: text/xml; charset=UTF-8\r\n" "%s" "Content-Length: %d\r\n\r\n" "%s", conn.uv.path, conn.uv.host, conn.uv.port, NOTNULL(conn.req_headers), post_data_sz, post_data); if (post != NULL) { AM_LOG_DEBUG(instance_id, "%s sending request:\n%s", thisfunc, post); if (log != NULL) { log("%s sending request:\n%s", thisfunc, post); } status = am_net_write(&conn, post, post_sz); free(post); } free(post_data); } } if (status == AM_SUCCESS) { wait_for_event(req_data.event, 0); } else { AM_LOG_DEBUG(instance_id, "%s disconnecting", thisfunc); if (log != NULL) { log("%s disconnecting", thisfunc); } am_net_diconnect(&conn); } AM_LOG_DEBUG(instance_id, "%s response status code: %d", thisfunc, conn.http_status); if (log != NULL) { log("%s response status code: %d", thisfunc, conn.http_status); } am_net_close(&conn); close_event(req_data.event); am_free(req_data.data); return status; }
int am_agent_login(unsigned long instance_id, const char *openam, const char *notifyurl, const char *user, const char *pass, const char *realm, int is_local, int lb_enable, struct am_ssl_options *info, char **agent_token, char **pxml, size_t *pxsz, struct am_namevalue **session_list, void(*log)(const char *, ...)) { static const char *thisfunc = "am_agent_login():"; am_net_t conn; int status = AM_ERROR; struct request_data req_data; if (!ISVALID(realm) || !ISVALID(user) || !ISVALID(pass) || !ISVALID(openam)) { return AM_EINVAL; } memset(&req_data, 0, sizeof(struct request_data)); memset(&conn, 0, sizeof(am_net_t)); conn.log = log; conn.instance_id = instance_id; conn.timeout = AM_NET_CONNECT_TIMEOUT; conn.url = openam; if (info != NULL) { memcpy(&conn.ssl.info, info, sizeof(struct am_ssl_options)); } if (lb_enable) { conn.req_headers = strdup("Cookie: amlbcookie="); } req_data.event = create_event(); if (req_data.event == NULL) return AM_ENOMEM; conn.data = &req_data; conn.on_connected = on_connected_cb; conn.on_close = on_close_cb; conn.on_data = on_agent_request_data_cb; conn.on_complete = on_complete_cb; if (am_net_connect(&conn) == 0) { do { /* authenticate with agent profile/password and module Application (PLL endpoint) */ status = send_authcontext_request(&conn, realm, agent_token); if (status != AM_SUCCESS) break; status = send_login_request(&conn, agent_token, user, pass); if (status != AM_SUCCESS) break; if (!is_local) { /* send agent attribute request (/identity/xml/read REST endpoint); * no interest in a remote profile in case of a local-only configuration */ status = send_attribute_request(&conn, agent_token, pxml, pxsz, user, realm); if (status != AM_SUCCESS) break; } /* send session request (PLL endpoint) */ status = send_session_request(&conn, agent_token, notifyurl, session_list); if (status != AM_SUCCESS) break; /* subscribe to a policy change notification (PLL endpoint) */ status = send_policychange_request(&conn, agent_token, notifyurl); } while (0); if (status != AM_SUCCESS) { AM_LOG_DEBUG(instance_id, "%s disconnecting", thisfunc); if (log != NULL) { log("%s disconnecting", thisfunc); } am_net_diconnect(&conn); } } am_net_close(&conn); close_event(req_data.event); am_free(req_data.data); return status; }
/** * Validate the specified URL by using HTTP HEAD request. */ int am_url_validate(unsigned long instance_id, const char* url, struct am_ssl_options* info, int* httpcode, void(*log)(const char *, ...)) { static const char* thisfunc = "am_url_validate():"; char* get = NULL; am_net_t conn; size_t get_sz; int status = AM_ERROR; struct request_data request_data; AM_LOG_DEBUG(instance_id, "%s%s", thisfunc, LOGEMPTY(url)); if (!ISVALID(url)) { return AM_EINVAL; } memset(&request_data, 0, sizeof(struct request_data)); memset(&conn, 0, sizeof(am_net_t)); conn.log = log; conn.instance_id = instance_id; conn.timeout = AM_NET_CONNECT_TIMEOUT; conn.url = url; if (info != NULL) { memcpy(&conn.ssl.info, info, sizeof(struct am_ssl_options)); } request_data.event = create_event(); if (request_data.event == NULL) { return AM_ENOMEM; } conn.data = &request_data; conn.on_connected = on_connected_cb; conn.on_close = on_close_cb; conn.on_data = on_agent_request_data_cb; conn.on_complete = on_complete_cb; if (am_net_connect(&conn) == 0) { AM_LOG_DEBUG(instance_id, "am_net_connect(%s) returns zero", url); if (log != NULL) { log("am_net_connect(%s) returns zero", url); } get_sz = am_asprintf(&get, "HEAD %s HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/plain\r\n" "Connection: close\r\n\r\n", conn.uv.path, conn.uv.host, conn.uv.port); if (get != NULL) { AM_LOG_DEBUG(instance_id, "%s sending request:\n%s", thisfunc, get); if (log != NULL) { log("%s sending request:\n%s", thisfunc, get); } status = am_net_write(&conn, get, get_sz); free(get); } } else { AM_LOG_DEBUG(instance_id, "am_net_connect(%s) returns NON zero", url); if (log != NULL) { log("am_net_connect(%s) returns NON zero", url); } } AM_LOG_DEBUG(instance_id, "status is set to %d", status); if (log != NULL) { log("status is set to %d", status); } if (status == AM_SUCCESS) { wait_for_event(request_data.event, 0); } else { AM_LOG_DEBUG(instance_id, "%s disconnecting", thisfunc); if (log != NULL) { log("%s disconnecting", thisfunc); } am_net_diconnect(&conn); } AM_LOG_DEBUG(instance_id, "%s response status code: %d", thisfunc, conn.http_status); if (log != NULL) { log("%s response status code: %d", thisfunc, conn.http_status); } if (httpcode) { *httpcode = conn.http_status; } am_net_close(&conn); close_event(request_data.event); am_free(request_data.data); return status; }
int main(int argc, char **argv) { int i; char *logfile_name=NULL; unsigned int seed=0; int sample_rate,paranoid,kernel_watchdog; FILE *fff; struct utsname uname_info; char cpuinfo[BUFSIZ]; int seed_specified=0; int c,j,missing=0; time_t timer; char buffer[26]; struct tm* tm_info; struct timeval current_time; long long interval_start=0; double rate; /*********************************/ /* Parse command line parameters */ /*********************************/ while ((c=getopt(argc, argv,"hvl:r:s:t:"))!=-1) { switch(c) { case 'h': /* help */ usage(argv[0],1); exit(0); break; case 'v': /* version */ usage(argv[0],0); exit(0); break; case 'l': /* log */ logging=TYPE_ALL; logfile_name=strdup(optarg); break; case 'r': /* seed */ seed=atoi(optarg); seed_specified=1; printf("Using user-specified random seed of %d\n",seed); break; case 's': /* stop */ stop_after=atoi(optarg); break; case 't': /* type */ type=0; for(j=0;j<strlen(optarg);j++) { switch(optarg[j]) { case 'O': type|=TYPE_OPEN; break; case 'C': type|=TYPE_CLOSE; break; case 'I': type|=TYPE_IOCTL; break; case 'R': type|=TYPE_READ; break; case 'M': type|=TYPE_MMAP; break; case 'F': type|=TYPE_FORK; break; case 'Q': type|=TYPE_TRASH_MMAP; break; case 'W': type|=TYPE_WRITE; break; case 'P': type|=TYPE_PRCTL; break; case 'p': type|=TYPE_POLL; break; case 'A': type|=TYPE_ACCESS; break; case 'o': type|=TYPE_OVERFLOW; break; case 'i': type|=TYPE_MILLION; break; default: printf("Unknown type %c\n", optarg[j]); } } break; default: usage(argv[0],1); exit(1); break; } } /****************/ /* Open logfile */ /****************/ if (logging) { if (!strcmp(logfile_name,"-")) { log_fd=1; /* stdout */ } else { log_fd=open(logfile_name,O_WRONLY|O_CREAT,0660); if (log_fd<0) { fprintf(stderr,"Error opening %s: %s\n", logfile_name,strerror(errno)); exit(1); } fprintf(stderr,"Warning! Using a named log file might disrupt determinism due to the extra file descriptor created. Consider logging to stdout instead\n\n"); } } /****************/ /* Print banner */ /****************/ printf("\n*** perf_fuzzer %s *** by Vince Weaver\n\n",VERSION); /*****************/ /* Print OS info */ /*****************/ uname(&uname_info); printf("\t%s version %s %s\n", uname_info.sysname,uname_info.release,uname_info.machine); /*****************/ /* Print cpuinfo */ /*****************/ get_cpuinfo(cpuinfo); printf("\tProcessor: %s\n",cpuinfo); /*****************/ /* Print options */ /*****************/ if (stop_after) printf("\tStopping after %d\n",stop_after); /* TODO: Make these configurable */ printf("\tWatchdog enabled with timeout %ds\n",WATCHDOG_TIMEOUT); printf("\tWill auto-exit if signal storm detected\n"); /**********************/ /* Print logging info */ /**********************/ if (logging) { printf("\tLogging to file: %s\n",logfile_name); printf("\tLogging perf_event_open() failures: %s\n", LOG_FAILURES?"yes":"no"); printf("\tRunning fsync after every syscall: %s\n", FSYNC_EVERY?"yes":"no"); } /************************************/ /* Seed the random number generator */ /************************************/ /* should read /dev/urandom instead? */ if (!seed) { seed=time(NULL); printf("\tSeeding RNG from time %d\n",seed); } else { printf("\tSeeding RNG with supplied seed %d\n",seed); } srand(seed); /* Write seed to disk so we can find it later */ fff=fopen("last.seed","w"); if (fff!=NULL) { fprintf(fff,"%d\n",seed); fclose(fff); } if (logging) { sprintf(log_buffer,"S %d\n",seed); write(log_fd,log_buffer,strlen(log_buffer)); } /************************/ /* setup watchdog timer */ /************************/ /* FIXME: make optional */ struct sigaction watchdog; memset(&watchdog, 0, sizeof(struct sigaction)); watchdog.sa_sigaction = alarm_handler; watchdog.sa_flags = SA_SIGINFO | SA_RESTART; if (sigaction( SIGALRM, &watchdog, NULL) < 0) { printf("Error setting up alarm handler\n"); } alarm(WATCHDOG_TIMEOUT); /******************************/ /* Initialize data structures */ /******************************/ /* Clear errnos count */ for(i=0;i<MAX_ERRNOS;i++) { stats.open_errno_count[i]=0; stats.fork_errno_count[i]=0; } /* Clear type counts */ for(i=0;i<MAX_OPEN_TYPE;i++) { stats.open_type_success[i]=0; stats.open_type_fail[i]=0; } /* Save our pid so we can re-map on replay */ if (logging) { sprintf(log_buffer,"G %d\n",getpid()); write(log_fd,log_buffer,strlen(log_buffer)); } /* Save the content of /proc/sys/kernel/perf_event_max_sample_rate */ /* If it has been changed, a replay might not be perfect */ sample_rate=get_sample_rate(); if (logging) { sprintf(log_buffer,"r %d\n",sample_rate); write(log_fd,log_buffer,strlen(log_buffer)); } /* Check kernel watchdog */ kernel_watchdog=get_kernel_watchdog_value(); /* Check paranoid setting */ paranoid=get_paranoid_value(); /*******************************/ /* Print reproduce information */ /*******************************/ printf("\n\tTo reproduce, try:\n"); printf("\t\techo %d > /proc/sys/kernel/nmi_watchdog\n", kernel_watchdog); printf("\t\techo %d > /proc/sys/kernel/perf_event_paranoid\n", paranoid); printf("\t\techo %d > /proc/sys/kernel/perf_event_max_sample_rate\n", sample_rate); printf("\t\t"); for(i=0;i<argc;i++) { printf("%s ",argv[i]); } if (!seed_specified) printf("-r %d",seed); printf("\n\n"); /* Print what we are actually fuzzing */ /* Sometimes I comment out code and forget */ missing=0; printf("\tFuzzing the following syscalls: "); if (type&TYPE_MMAP) printf("mmap "); else missing++; if (type&TYPE_OPEN) printf("perf_event_open "); else missing++; if (type&TYPE_CLOSE) printf("close "); else missing++; if (type&TYPE_READ) printf("read "); else missing++; if (type&TYPE_WRITE) printf("write "); else missing++; if (type&TYPE_IOCTL) printf("ioctl "); else missing++; if (type&TYPE_FORK) printf("fork "); else missing++; if (type&TYPE_PRCTL) printf("prctl "); else missing++; if (type&TYPE_POLL) printf("poll "); else missing++; printf("\n"); if (missing) { printf("\t*NOT* Fuzzing the following syscalls: "); if (!(type&TYPE_MMAP)) printf("mmap "); if (!(type&TYPE_OPEN)) printf("perf_event_open "); if (!(type&TYPE_CLOSE)) printf("close "); if (!(type&TYPE_READ)) printf("read "); if (!(type&TYPE_WRITE)) printf("write "); if (!(type&TYPE_IOCTL)) printf("ioctl "); if (!(type&TYPE_FORK)) printf("fork "); if (!(type&TYPE_PRCTL)) printf("prctl "); if (!(type&TYPE_POLL)) printf("poll "); printf("\n"); } missing=0; printf("\tAlso attempting the following: "); if (type&TYPE_OVERFLOW) printf("signal-handler-on-overflow "); else missing++; if (type&TYPE_MILLION) printf("busy-instruction-loop "); else missing++; if (type&TYPE_ACCESS) printf("accessing-perf-proc-and-sys-files "); else missing++; if (type&TYPE_TRASH_MMAP) printf("trashing-the-mmap-page "); else missing++; printf("\n"); if (missing) { printf("\t*NOT* attempting the following: "); if (!(type&TYPE_OVERFLOW)) printf("signal-handler-on-overflow "); if (!(type&TYPE_MILLION)) printf("busy-instruction-loop "); if (!(type&TYPE_ACCESS)) printf("accessing-perf-proc-and-sys-files "); if (!(type&TYPE_TRASH_MMAP)) printf("trashing-the-mmap-page "); printf("\n"); } if (attempt_determinism) { printf("\n\tAttempting more deterministic results by:\n\t"); printf("waitpid-after-killing-child "); printf("disabling-overflow-signal-handler "); printf("\n"); /* Disable overflows if trying for determinism */ if (attempt_determinism) { type&=~TYPE_OVERFLOW; } } /******************************************/ /* Set up to match trinity setup, vaguely */ /******************************************/ page_size=getpagesize(); //printf("Page size=%d\n",page_size); num_online_cpus = sysconf(_SC_NPROCESSORS_ONLN); create_shm(); create_shm_arrays(); init_shm(); // init_shared_pages(); syscall_perf_event_open.init(); /* Initialize PMU names if possible */ /* This depends on trinity exporting the values */ if (pmus!=NULL) { for(i=0;i<num_pmus;i++) { if (pmus[i].type<MAX_OPEN_TYPE) { stats_set_pmu_name(pmus[i].type,pmus[i].name); } } } /************************/ /* Set up SIGIO handler */ /************************/ /* In theory we shouldn't get SIGIO as we set up SIGRT for overflow */ /* But if the RT queue overflows we will get a SIGIO */ memset(&sigio, 0, sizeof(struct sigaction)); sigio.sa_sigaction = sigio_handler; sigio.sa_flags = SA_SIGINFO; if (sigaction( SIGIO, &sigio, NULL) < 0) { printf("Error setting up SIGIO signal handler\n"); } /* Set up SIGQUIT handler */ memset(&sigquit, 0, sizeof(struct sigaction)); sigquit.sa_sigaction = sigquit_handler; sigquit.sa_flags = SA_SIGINFO; if (sigaction( SIGQUIT, &sigquit, NULL) < 0) { printf("Error setting up SIGQUIT signal handler\n"); } /* Initialize Event Structure */ for(i=0;i<NUM_EVENTS;i++) { event_data[i].active=0; event_data[i].fd=0; event_data[i].read_size=rand(); } /* Sleep to make it easier to ftrace/ptrace */ printf("\n\tPid=%d, sleeping 1s\n\n",getpid()); sleep(1); /* Print start time */ time(&timer); tm_info = localtime(&timer); strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info); printf("==================================================\n"); printf("Starting fuzzing at %s\n",buffer); printf("==================================================\n"); gettimeofday(¤t_time,NULL); interval_start=current_time.tv_sec; /****************/ /* MAIN LOOP */ /****************/ while(1) { switch(rand()%11) { case 0: if (type&TYPE_OPEN) { open_random_event(type&TYPE_MMAP, type&TYPE_OVERFLOW); } break; case 1: if (type&TYPE_CLOSE) { // if (rand()%3==0) close_random_event(); } break; case 2: if (type&TYPE_IOCTL) { ioctl_random_event(); } break; case 3: if (type&TYPE_PRCTL) { prctl_random_event(); } break; case 4: if (type&TYPE_READ) { read_random_event(); } break; case 5: if (type&TYPE_WRITE) { write_random_event(); } break; case 6: if (type&TYPE_ACCESS) { access_random_file(); } break; case 7: if (type&TYPE_FORK) { fork_random_event(); } break; case 8: if (type&TYPE_POLL) { poll_random_event(); } break; case 9:if (type&TYPE_MMAP) { mmap_random_event(type); } break; default: if (type&TYPE_MILLION) { run_a_million_instructions(); } break; } #if FSYNC_EVERY if (logging) fsync(log_fd); #endif if (throttle_close_event) { printf("Closing stuck event %d\n", throttle_close_event); close_event(throttle_close_event,1); throttle_close_event=0; } next_overflow_refresh=rand()%2; next_refresh=rand_refresh(); stats.total_iterations++; watchdog_counter++; if ((stop_after) && (stats.total_iterations>=stop_after)) { long long end_count; end_count=stats.total_iterations% STATUS_UPDATE_INTERVAL; if ((end_count==0) && (stats.total_iterations>0)) { end_count=STATUS_UPDATE_INTERVAL; } gettimeofday(¤t_time,NULL); rate=((double)(end_count))/ (current_time.tv_sec-interval_start); dump_summary(stderr,1,rate); /* Kill child, doesn't happen automatically? */ if (already_forked) { int status; kill(forked_pid,SIGKILL); waitpid(forked_pid, &status, 0); } return 0; } /* Print status update every 10000 iterations */ /* Don't print if logging to stdout as it clutters */ /* up the trace file. */ if (stats.total_iterations%STATUS_UPDATE_INTERVAL==0) { gettimeofday(¤t_time,NULL); rate=((double)STATUS_UPDATE_INTERVAL)/ (current_time.tv_sec-interval_start); if (log_fd!=1) { dump_summary(stderr,1,rate); } else { dump_summary(stderr,0,rate); } interval_start=current_time.tv_sec; } // fsync(log_fd); } return 0; }
void Application::init_connections(){ CONNECT (player, pause(), listen, pause()); CONNECT (player, search(int), listen, jump(int)); CONNECT (player, sig_volume_changed(int), listen, setVolume(int)); CONNECT (player, sig_rec_button_toggled(bool), listen, record_button_toggled(bool)); CONNECT (player, setupLastFM(), ui_lastfm, show_win()); // IND CONNECT (player, baseDirSelected(const QString &), library, baseDirSelected(const QString & )); CONNECT (player, reloadLibrary(), library, reloadLibrary()); CONNECT (player, importDirectory(QString), library, importDirectory(QString)); CONNECT (player, libpath_changed(QString), library, setLibraryPath(QString)); CONNECT (player, fileSelected(QStringList &), playlist, psl_createPlaylist(QStringList&)); CONNECT (player, play(), playlist, psl_play()); CONNECT (player, stop(), playlist, psl_stop()); CONNECT (player, forward(), playlist, psl_forward()); CONNECT (player, backward(), playlist, psl_backward()); CONNECT (player, sig_stream_selected(const QString&, const QString&), playlist, psl_play_stream(const QString&, const QString&)); CONNECT (player, show_playlists(), ui_playlist_chooser, show()); // IND CONNECT (player, skinChanged(bool), ui_playlist, change_skin(bool)); CONNECT (player, show_small_playlist_items(bool), ui_playlist, psl_show_small_playlist_items(bool)); CONNECT (player, sig_sound_engine_changed(QString&), plugin_loader, psl_switch_engine(QString&)); CONNECT (player, sig_show_stream_rec(bool), ui_stream_rec, psl_show(bool)); // IND CONNECT (player, sig_show_socket(), ui_socket_setup, show()); // IND CONNECT (player, sig_correct_id3(const MetaData&), ui_id3_editor, change_meta_data(const MetaData&)); // IND CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), player, update_track(const MetaData&)); CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), listen, changeTrack(const MetaData & )); CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), lastfm, psl_track_changed(const MetaData&)); CONNECT (playlist, sig_no_track_to_play(), listen, stop()); CONNECT (playlist, sig_goon_playing(), listen, play()); CONNECT (playlist, sig_selected_file_changed(int), ui_playlist, track_changed(int)); CONNECT (playlist, sig_playlist_created(vector<MetaData>&, int), ui_playlist, fillPlaylist(vector<MetaData>&, int)); //CONNECT (&playlist, sig_cur_played_info_changed(const MetaData&), &player, update_info(const MetaData&)); CONNECT (playlist, sig_playlist_prepared(int, vector<MetaData>&), playlists, save_playlist_as_custom(int, vector<MetaData>&)); CONNECT (playlist, sig_playlist_prepared(QString, vector<MetaData>&), playlists, save_playlist_as_custom(QString, vector<MetaData>&)); CONNECT (playlist, sig_library_changed(), ui_library, library_changed()); CONNECT (playlist, sig_import_files(const vector<MetaData>&), library, importFiles(const vector<MetaData>&)); CONNECT (playlist, sig_need_more_radio(), lastfm, psl_radio_playlist_request()); CONNECT (playlist, sig_radio_active(int), player, set_radio_active(int)); CONNECT (playlist, sig_radio_active(int), ui_playlist, set_radio_active(int)); // Can be done inside player CONNECT (playlist, sig_radio_active(int), ui_playlist_chooser, set_radio_active(int)); CONNECT (playlist, sig_data_for_id3_change(const vector<MetaData>&), ui_id3_editor, change_meta_data(const vector<MetaData>&)); // IND CONNECT (ui_playlist, selected_row_changed(int), playlist, psl_change_track(int)); CONNECT (ui_playlist, clear_playlist(), playlist, psl_clear_playlist()); CONNECT (ui_playlist, playlist_mode_changed(const Playlist_Mode&), playlist, psl_playlist_mode_changed(const Playlist_Mode&)); CONNECT (ui_playlist, dropped_tracks(const vector<MetaData>&, int), playlist, psl_insert_tracks(const vector<MetaData>&, int)); CONNECT (ui_playlist, sound_files_dropped(QStringList&), playlist, psl_createPlaylist(QStringList&)); CONNECT (ui_playlist, directory_dropped(const QString&, int), playlist, psl_directoryDropped(const QString &, int )); CONNECT (ui_playlist, rows_removed(const QList<int>&), playlist, psl_remove_rows(const QList<int>&)); CONNECT (ui_playlist, sig_import_to_library(bool), playlist, psl_import_new_tracks_to_library(bool)); CONNECT (listen, track_finished(), playlist, psl_next_track() ); CONNECT (listen, sig_valid_strrec_track(const MetaData&), playlist, psl_valid_strrec_track(const MetaData&)); CONNECT (listen, scrobble_track(const MetaData&), lastfm, psl_scrobble(const MetaData&)); // should be sent to player CONNECT (listen, eq_presets_loaded(const vector<EQ_Setting>&), ui_eq, fill_eq_presets(const vector<EQ_Setting>&)); CONNECT (listen, eq_found(const QStringList&), ui_eq, fill_available_equalizers(const QStringList&)); CONNECT (listen, total_time_changed_signal(qint64), player, total_time_changed(qint64)); CONNECT (listen, timeChangedSignal(quint32), player, setCurrentPosition(quint32) ); CONNECT(library, sig_playlist_created(QStringList&), playlist, psl_createPlaylist(QStringList&)); CONNECT(library, sig_import_result(bool), playlist, psl_import_result(bool)); CONNECT(library, sig_import_result(bool), ui_playlist, import_result(bool)); CONNECT(library, sig_reload_library_finished(), ui_library, reloading_library_finished()); CONNECT(library, sig_reloading_library(QString&), ui_library, reloading_library(QString&)); CONNECT(library, sig_import_result(bool), ui_library, import_result(bool)); CONNECT(library, sig_metadata_loaded(vector<MetaData>&), ui_library, fill_library_tracks(vector<MetaData>&)); CONNECT(library, sig_all_albums_loaded(vector<Album>&), ui_library, fill_library_albums(vector<Album>&)); CONNECT(library, sig_all_artists_loaded(vector<Artist>&), ui_library, fill_library_artists(vector<Artist>&)); CONNECT(library, sig_track_mime_data_available(const vector<MetaData>&), ui_library, track_info_available(const vector<MetaData>&)); CONNECT(library, sig_tracks_for_playlist_available(vector<MetaData>&), playlist, psl_createPlaylist(vector<MetaData>&)); CONNECT(library, sig_import_result(bool), playlists, import_result(bool)); CONNECT(library, sig_delete_answer(QString), ui_library, psl_delete_answer(QString)); CONNECT(library, sig_play_next_tracks(const vector<MetaData>&), playlist, psl_play_next_tracks(const vector<MetaData>&)); if(ui_id3_editor) CONNECT(library, sig_change_id3_tags(const vector<MetaData>&), ui_id3_editor, change_meta_data(const vector<MetaData>&)); // IND CONNECT(ui_library, sig_album_dbl_clicked(), library, psl_prepare_album_for_playlist()); CONNECT(ui_library, sig_artist_dbl_clicked(), library, psl_prepare_artist_for_playlist()); CONNECT(ui_library, sig_track_dbl_clicked(int), library, psl_prepare_track_for_playlist(int)); CONNECT(ui_library, sig_artist_pressed(const QList<int>&), library, psl_selected_artists_changed(const QList<int>&)); CONNECT(ui_library, sig_album_pressed(const QList<int>&), library, psl_selected_albums_changed(const QList<int>&)); CONNECT(ui_library, sig_track_pressed(const QList<int>&), library, psl_selected_tracks_changed(const QList<int>&)); CONNECT(ui_library, sig_filter_changed(const Filter&), library, psl_filter_changed(const Filter&)); CONNECT(ui_library, sig_sortorder_changed(Sort::ArtistSort, Sort::AlbumSort, Sort::TrackSort), library, psl_sortorder_changed(Sort::ArtistSort, Sort::AlbumSort, Sort::TrackSort)); CONNECT(ui_library, sig_show_id3_editor(const QList<int>&), library, psl_change_id3_tags(const QList<int>&)); CONNECT(ui_library, sig_delete_tracks(int), library, psl_delete_tracks(int)); CONNECT(ui_library, sig_delete_certain_tracks(const QList<int>&, int), library, psl_delete_certain_tracks(const QList<int>&, int)); CONNECT(ui_library, sig_play_next_tracks(const QList<int>&), library, psl_play_next_tracks(const QList<int>&)); CONNECT(ui_library, sig_play_next_all_tracks(), library, psl_play_next_all_tracks()); CONNECT(ui_lastfm, sig_activated(bool), player, psl_lfm_activated(bool)); CONNECT(ui_lastfm, sig_activated(bool), ui_playlist, psl_lfm_activated(bool)); CONNECT(ui_lastfm, new_lfm_credentials(QString, QString), lastfm, psl_login(QString, QString)); CONNECT(ui_eq, eq_changed_signal(int, int), listen, eq_changed(int, int)); CONNECT(ui_eq, eq_enabled_signal(bool), listen, eq_enable(bool)); CONNECT(ui_eq, close_event(), player, close_eq()); CONNECT(ui_playlist, edit_id3_signal(), playlist, psl_edit_id3_request()); CONNECT(ui_id3_editor, id3_tags_changed(), ui_library, id3_tags_changed()); CONNECT(ui_id3_editor, id3_tags_changed(vector<MetaData>&), playlist, psl_id3_tags_changed(vector<MetaData>&)); CONNECT(ui_id3_editor, id3_tags_changed(vector<MetaData>&), player, psl_id3_tags_changed(vector<MetaData>&)); CONNECT(lastfm, sig_similar_artists_available(const QList<int>&), playlist, psl_similar_artists_available(const QList<int>&)); CONNECT(lastfm, sig_last_fm_logged_in(bool), ui_playlist, last_fm_logged_in(bool)); CONNECT(lastfm, sig_last_fm_logged_in(bool), player, last_fm_logged_in(bool)); CONNECT(lastfm, sig_new_radio_playlist(const vector<MetaData>&), playlist, psl_new_radio_playlist_available(const vector<MetaData>&)); CONNECT(lastfm, sig_track_info_fetched(const MetaData&, bool, bool), player, lfm_info_fetched(const MetaData&, bool, bool)); CONNECT(ui_playlist_chooser, sig_playlist_chosen(int), playlists, load_single_playlist(int)); CONNECT(ui_playlist_chooser, sig_delete_playlist(int), playlists, delete_playlist(int)); CONNECT(ui_playlist_chooser, sig_save_playlist(int), playlist, psl_prepare_playlist_for_save(int)); CONNECT(ui_playlist_chooser, sig_save_playlist(QString), playlist, psl_prepare_playlist_for_save(QString)); CONNECT(ui_playlist_chooser, sig_clear_playlist(), playlist, psl_clear_playlist()); CONNECT(ui_playlist_chooser, sig_closed(), player, close_playlist_chooser()); CONNECT(playlists, sig_single_playlist_loaded(CustomPlaylist&), playlist, psl_createPlaylist(CustomPlaylist&)); CONNECT(playlists, sig_all_playlists_loaded(QMap<int, QString>&), ui_playlist_chooser, all_playlists_fetched(QMap<int, QString>&)); CONNECT(playlists, sig_import_tracks(const vector<MetaData>&), library, importFiles(const vector<MetaData>&)); CONNECT(ui_lfm_radio, listen_clicked(const QString&, int), lastfm, psl_radio_init(const QString&, int)); CONNECT(ui_lfm_radio, close_event(), player, close_lfm_radio()); CONNECT(ui_stream, sig_play_stream(const QString&, const QString&), playlist, psl_play_stream(const QString&, const QString&)); CONNECT(ui_stream, sig_close_event(), player, close_stream()); CONNECT (ui_stream_rec, sig_stream_recorder_active(bool), listen, psl_strrip_set_active(bool)); CONNECT (ui_stream_rec, sig_stream_recorder_active(bool), player, psl_strrip_set_active(bool)); CONNECT (ui_stream_rec, sig_path_changed(const QString&), listen, psl_strrip_set_path(const QString& )); CONNECT (ui_stream_rec, sig_complete_tracks(bool), listen, psl_strrip_complete_tracks(bool)); CONNECT (ui_stream_rec, sig_create_playlist(bool), listen, psl_strrip_set_create_playlist(bool )); bool is_socket_active = set->getSocketActivated(); if(is_socket_active){ CONNECT (remote_socket, sig_play(), playlist, psl_play()); CONNECT (remote_socket, sig_next(), playlist, psl_forward()); CONNECT (remote_socket, sig_prev(), playlist, psl_backward()); CONNECT (remote_socket, sig_stop(), playlist, psl_stop()); CONNECT (remote_socket, sig_pause(), listen, pause()); CONNECT (remote_socket, sig_setVolume(int),player, setVolume(int)); remote_socket->start(); } }
int main(int argc, char **argv) { FILE *logfile; char line[BUFSIZ]; char *result; long long total_syscalls=0; int random_seed; int max_sample_rate; if (argc<2) { logfile=stdin; // fprintf(stderr,"\nUsage: %s logfile\n\n", // argv[0]); // exit(1); } else { logfile=fopen(argv[1],"r"); if (logfile==NULL) { fprintf(stderr,"Error opening %s\n",argv[1]); exit(1); } } printf("/* log_to_code output from %s */\n",argv[1]); printf("/* by Vince Weaver <vincent.weaver _at_ maine.edu> */\n\n"); printf("#define _GNU_SOURCE 1\n"); printf("#include <stdio.h>\n"); printf("#include <unistd.h>\n"); printf("#include <fcntl.h>\n"); printf("#include <string.h>\n"); printf("#include <signal.h>\n"); printf("#include <sys/mman.h>\n"); printf("#include <sys/syscall.h>\n"); printf("#include <sys/ioctl.h>\n"); printf("#include <sys/prctl.h>\n"); printf("#include <sys/wait.h>\n"); printf("#include <poll.h>\n"); printf("#include <linux/hw_breakpoint.h>\n"); printf("#include <linux/perf_event.h>\n"); printf("\n"); printf("static int fd[%d];\n",NUM_VALUES); printf("static struct perf_event_attr pe[%d];\n",NUM_VALUES); printf("static char *mmap_result[%d];\n",NUM_VALUES); printf("#define MAX_READ_SIZE 65536\n"); printf("static long long data[MAX_READ_SIZE];\n"); printf("\n"); printf("#define MAX_POLL_FDS 128\n"); printf("static struct pollfd pollfds[MAX_POLL_FDS];\n"); printf("\n"); /* For ioctl(PERF_EVENT_IOC_ID); */ printf("static long long id;\n"); /* For ioctl(PERF_EVENT_IOC_PERIOD); */ printf("static long long period;\n"); printf("\n"); printf("static int status;\n"); printf("static int forked_pid;\n\n"); printf("static struct sigaction sa;\n"); printf("static int overflows=0;\n"); printf("static int sigios=0;\n\n"); printf("FILE *fff;\n"); printf("static int result;\n"); printf("static long long size;\n"); printf("static char buffer[2048];\n\n"); printf("static void our_handler(int signum, siginfo_t *info, void *uc) {\n"); printf("\tint fd = info->si_fd;\n"); printf("\tint ret;\n\n"); printf("\toverflows++;\n"); printf("\tioctl(fd,PERF_EVENT_IOC_DISABLE,0);\n"); printf("\tif (sigios) return;\n"); printf("\tret=ioctl(fd, PERF_EVENT_IOC_REFRESH,1);\n"); printf("}\n\n"); printf("int perf_event_open(struct perf_event_attr *hw_event_uptr,\n"); printf("\tpid_t pid, int cpu, int group_fd, unsigned long flags) {\n"); printf("\n"); printf("\treturn syscall(__NR_perf_event_open,hw_event_uptr, pid, cpu,\n"); printf("\t\tgroup_fd, flags);\n"); printf("}\n\n"); printf("int main(int argc, char **argv) {\n"); /* Match how replay_log implements things */ printf("\n\tint i;\n"); printf("\tfor(i=0;i<%d;i++) fd[i]=-1;\n\n",NUM_VALUES); while(1) { result=fgets(line,BUFSIZ,logfile); if (result==NULL) break; line_num++; printf("/* %lld */\n",line_num); //printf("printf(\"Line: %lld\\n\");\n",line_num); switch(line[0]) { case 'A': access_event(line); total_syscalls++; break; case 'C': close_event(line); total_syscalls++; break; case 'F': fork_event(line); total_syscalls++; break; case 'G': sscanf(line,"%*c %d",&original_pid); break; case 'I': ioctl_event(line); total_syscalls++; break; case 'M': mmap_event(line); total_syscalls++; break; case 'O': open_event(line); total_syscalls++; break; case 'o': setup_overflow(line); total_syscalls++; break; case 'P': prctl_event(line); total_syscalls++; break; case 'p': poll_event(line); total_syscalls++; break; case 'Q': trash_mmap_event(line); total_syscalls++; break; case 'R': read_event(line); total_syscalls++; break; case 'r': sscanf(line,"%*c %d",&max_sample_rate); printf("/* /proc/sys/kernel/perf_event_max_sample_rate was %d */\n",max_sample_rate); break; case 'S': sscanf(line,"%*c %d",&random_seed); printf("/* Random Seed was %d */\n",random_seed); break; case 'U': munmap_event(line); total_syscalls++; break; default: fprintf(stderr,"Unknown log type \'%c\'\n", line[0]); break; } if (error) break; } printf("\n\n\t/* Replayed %lld syscalls */\n",total_syscalls); printf("\treturn 0;\n"); printf("}\n"); return 0; }
int main(int argc, char **argv) { FILE *logfile,*fff; char *logfile_name=NULL; char *result; long long total_syscalls=0,replay_syscalls=0; long long skip_lines=0; long long stop_lines=0; struct sigaction sigio; int i,j,seed=0xdeadbeef; int replay_which=REPLAY_ALL; int sample_rate,old_sample_rate; /* init */ for(i=0;i<FD_REMAP_SIZE;i++) fd_remap[i]=-1; // if (argc<2) { // print_usage(argv[0]); // exit(1); // } i=1; while(1) { if (i>=argc) break; if (argv[i][0]=='-') { switch(argv[i][1]) { case 'h': print_usage(argv[0]); exit(1); break; case 'p': i++; if (i<argc) { stop_lines=atoll(argv[i]); printf("stopping after %lld lines\n",stop_lines); i++; } break; case 's': i++; if (i<argc) { skip_lines=atoll(argv[i]); printf("skipping %lld lines\n",skip_lines); i++; } break; case 'r': replay_which=0; i++; for(j=0;j<strlen(argv[i]);j++) { switch(argv[i][j]) { case 'O': replay_which|=REPLAY_OPEN; break; case 'o': replay_which|=REPLAY_OVERFLOW; break; case 'C': replay_which|=REPLAY_CLOSE; break; case 'I': replay_which|=REPLAY_IOCTL; break; case 'R': replay_which|=REPLAY_READ; break; case 'M': replay_which|=REPLAY_MMAP; break; case 'U': replay_which|=REPLAY_MUNMAP; break; case 'P': replay_which|=REPLAY_PRCTL; break; case 'F': replay_which|=REPLAY_FORK; break; case 'p': replay_which|=REPLAY_POLL; break; default: fprintf(stderr,"Unknown replay %c\n", argv[i][j]); } } i++; break; default: fprintf(stderr,"Unknown option -%c\n",argv[i][1]); exit(1); break; } } else { logfile_name=strdup(argv[i]); i++; } } if (logfile_name==NULL) { // fprintf(stderr,"Must specify logfile name\n"); // exit(1); logfile=stdin; } else { logfile=fopen(logfile_name,"r"); if (logfile==NULL) { fprintf(stderr,"Error opening %s\n",logfile_name); exit(1); } } printf("Replaying...\n"); /* Write fake seed to disk */ /* trying to make the syscall trace more similar to the actual fuzzer */ fff=fopen("fake.seed","w"); if (fff!=NULL) { fprintf(fff,"%d\n",seed); fclose(fff); } /* Save the content of /proc/sys/kernel/perf_event_max_sample_rate */ /* If it has been changed, a replay might not be perfect */ sample_rate=get_sample_rate(); /* Set up to match trinity setup, vaguely */ page_size=getpagesize(); syscall_perf_event_open.init(); shm=calloc(1,sizeof(struct shm_s)); page_rand = memalign(page_size, page_size * 2); if (!page_rand) { exit(EXIT_FAILURE); } memset(page_rand, 0x55, page_size); /* Set up SIGIO handler */ /* In theory we shouldn't get SIGIO as we set up SIGRT for overflow */ /* But if the RT queue overflows we will get a SIGIO */ memset(&sigio, 0, sizeof(struct sigaction)); sigio.sa_sigaction = sigio_handler; sigio.sa_flags = SA_SIGINFO; if (sigaction( SIGIO, &sigio, NULL) < 0) { printf("Error setting up SIGIO signal handler\n"); } while(1) { result=fgets(line,BUFSIZ,logfile); if (result==NULL) break; line_num++; if (debug) printf("%lld %s",line_num,line); /* don't want to skip the random seed, etc */ if ((line_num>2) && (line_num<skip_lines)) continue; switch(line[0]) { case 'A': if (replay_which & REPLAY_ACCESS) { access_event(line); replay_syscalls++; } break; case 'C': if (replay_which & REPLAY_CLOSE) { close_event(line); replay_syscalls++; } break; case 'F': if (replay_which & REPLAY_FORK) { fork_event(line); replay_syscalls++; } break; case 'G': sscanf(line,"%*c %d",&original_pid); printf("Original pid was %d\n",original_pid); break; case 'I': if (replay_which & REPLAY_IOCTL) { ioctl_event(line); replay_syscalls++; } break; case 'M': if (replay_which & REPLAY_MMAP) { mmap_event(line); replay_syscalls++; } break; case 'O': if (replay_which & REPLAY_OPEN) { open_event(line); replay_syscalls++; } break; case 'o': if (replay_which & REPLAY_OVERFLOW) { setup_overflow(line); replay_syscalls++; } break; case 'P': if (replay_which & REPLAY_PRCTL) { prctl_event(line); replay_syscalls++; } break; case 'p': if (replay_which & REPLAY_POLL) { poll_event(line); replay_syscalls++; } break; case 'Q': if (replay_which & REPLAY_TRASH_MMAP) { trash_mmap_event(line); replay_syscalls++; } break; case 'q': fprintf(stderr,"Quitting early\n"); exit(1); case 'R': if (replay_which & REPLAY_READ) { read_event(line); replay_syscalls++; } break; case 'r': sscanf(line,"r %d",&old_sample_rate); //sample_rate=get_sample_rate(); if (sample_rate!=old_sample_rate) { printf("Warning! The current max sample rate is %d\n",sample_rate); printf("\tThis log was recorded when it was %d\n",old_sample_rate); printf("\tFor proper replay you might want to (as root):\n\techo \"%d\" > /proc/sys/kernel/perf_event_max_sample_rate\n",old_sample_rate); } break; case 'S': if (replay_which & REPLAY_SEED) { /* don't need to do anything */ /* as we don't use rand */ } break; case 'U': if (replay_which & REPLAY_MUNMAP) { munmap_event(line); replay_syscalls++; } break; case '#': /* skip */ break; default: fprintf(stderr,"Line %lld Unknown log type \'%c\'\n", line_num,line[0]); break; } //if (error) break; total_syscalls++; if (total_syscalls%1000==0) { printf("%lld\n",total_syscalls); } if (stop_lines && (total_syscalls > stop_lines)) break; } /* Kill any lingering children */ if (forked_pid) { kill(forked_pid,SIGKILL); } printf("Replayed %lld of %lld syscalls\n", replay_syscalls,total_syscalls); return 0; }
int am_agent_naming_request(unsigned long instance_id, const char *openam, const char *token) { char *post = NULL, *post_data = NULL; am_net_t n; size_t post_sz; int status = AM_ERROR; struct request_data ld; if (!ISVALID(token) || !ISVALID(openam)) return AM_EINVAL; memset(&ld, 0, sizeof(struct request_data)); memset(&n, 0, sizeof(am_net_t)); n.instance_id = instance_id; n.timeout = AM_NET_CONNECT_TIMEOUT; n.url = openam; ld.event = create_event(); if (ld.event == NULL) return AM_ENOMEM; n.data = &ld; n.on_connected = on_connected_cb; n.on_close = on_close_cb; n.on_data = on_agent_request_data_cb; n.on_complete = on_complete_cb; if (am_net_connect(&n) == 0) { size_t post_data_sz = am_asprintf(&post_data, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" "<RequestSet vers=\"1.0\" svcid=\"com.iplanet.am.naming\" reqid=\"0\">" "<Request><![CDATA[" "<NamingRequest vers=\"3.0\" reqid=\"1\" sessid=\"%s\">" "<GetNamingProfile>" "</GetNamingProfile>" "</NamingRequest>]]>" "</Request>" "</RequestSet>", token); if (post_data != NULL) { post_sz = am_asprintf(&post, "POST %s/namingservice HTTP/1.1\r\n" "Host: %s:%d\r\n" "User-Agent: "MODINFO"\r\n" "Accept: text/xml\r\n" "Connection: close\r\n" "Content-Type: text/xml; charset=UTF-8\r\n" "Content-Length: %d\r\n\r\n" "%s", n.uv.path, n.uv.host, n.uv.port, post_data_sz, post_data); if (post != NULL) { status = am_net_write(&n, post, post_sz); free(post); post = NULL; } free(post_data); post_data = NULL; } } if (status == AM_SUCCESS) { wait_for_event(ld.event, 0); } else { am_net_diconnect(&n); } am_net_close(&n); close_event(ld.event); am_free(ld.data); return status; }