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;
}
