static QUERY(sniff_status_show) { char *uid = *(va_arg(ap, char **)); session_t *s = session_find(uid); struct pcap_stat stats; if (!s) return -1; if (!s->connected) return 0; if (!s->priv) { debug_error("sniff_status_show() s->priv NULL\n"); return -1; } /* Device: DEVICE (PROMISC?) */ /* some stats */ memset(&stats, 0, sizeof(struct pcap_stat)); if (pcap_stats(GET_DEV(s), &stats) == -1) { debug_error("sniff_status_show() pcap_stats() failed\n"); return -1; } debug("pcap_stats() recv: %d drop: %d ifdrop: %d\n", stats.ps_recv, stats.ps_drop, stats.ps_ifdrop); print("sniff_pkt_rcv", session_name(s), ekg_itoa(stats.ps_recv)); print("sniff_pkt_drop", session_name(s), ekg_itoa(stats.ps_drop)); print("sniff_conn_db", session_name(s), ekg_itoa(list_count(tcp_connections))); return 0; }
static void __display_info(session_t *s, int type, private_data_t *data) { int i, uid = private_item_get_int(&data, "uid"); const char *str; char *theme = saprintf("icq_userinfo_%s", icq_lookuptable(meta_name, type)); for (i=0; userinfo[i].type; i++) { if ( (userinfo[i].type != type) || (!userinfo[i].name) ) continue; if (userinfo[i].ltab) str = icq_lookuptable(userinfo[i].ltab, private_item_get_int(&data, userinfo[i].name)); else if (userinfo[i].item == 'L') str = private_item_get_int(&data, userinfo[i].name) ? _("Yes") : _("No"); else str = private_item_get(&data, userinfo[i].name); if ( str && *str) { char *___str = xstrdup(str); /* XXX, guess recode */ if (!__displayed) print("icq_userinfo_start", session_name(s), itoa(uid), theme); print(theme, session_name(s), itoa(uid), userinfo[i].display, ___str); __displayed = 1; xfree(___str); } } xfree(theme); }
/* we return 0 even if rmwatch fails, because xmsg_handle_data checks * if our session is still connected, so it'll ignore unneeded events */ static COMMAND(xmsg_disconnect) { if (!session_connected_get(session)) { printq("not_connected", session_name(session)); return -1; } xmsg_timer_change(session, NULL); if (!timer_remove_session(session, "o")) xdebug("old oneshot resume timer removed"); session_status_set(session, EKG_STATUS_NA); if (quiet == -1) protocol_disconnected_emit(session, format_find("xmsg_umount"), EKG_DISCONNECT_NETWORK); else protocol_disconnected_emit(session, NULL, EKG_DISCONNECT_USER); #ifdef HAVE_INOTIFY if (session->priv && inotify_rm_watch(in_fd, (long int) session->priv)) xdebug2(DEBUG_ERROR, "rmwatch failed"); else xdebug("inotify watch removed: %d", (long int) session->priv); #endif /*HAVE_INOTIFY*/ return 0; }
static COMMAND(xmsg_connect) { if (session_connected_get(session)) { printq("already_connected", session_name(session)); return -1; } if (command_exec(NULL, session, "/session --lock", 0) == -1) return -1; if (xmsg_add_watch(session, session_uid_get(session)+XMSG_UID_DIROFFSET)) { print("conn_failed", format_find("xmsg_addwatch_failed"), session_name(session)); return -1; } session_status_set(session, EKG_STATUS_AVAIL); protocol_connected_emit(session); xmsg_iterate_dir(0, (void*) session); xmsg_timer_change(session, "rescan_timer"); return 0; }
static COMMAND(sniff_command_disconnect) { if (!session_connected_get(session)) { printq("not_connected", session_name(session)); return -1; } protocol_disconnected_emit(session, NULL, EKG_DISCONNECT_USER); if (!GET_DEV(session)) { debug_error("sniff_command_disconnect() not dev?!\n"); return -1; } pcap_close(GET_DEV(session)); session->priv = NULL; return 0; }
void muroa::CCmdStreamTests::serializeRequestJoin() { boost::asio::ip::address server_addr = address::from_string("192.168.1.77"); uint32_t cmdID = 2; string session_name("default session"); evRequestJoin rjoin; rjoin.m_cmd_id = cmdID; rjoin.m_session_name = session_name; rjoin.m_mcast_addr = server_addr; m_rpc_s->sendEvent(&rjoin); const CmdStreamBase* cmdBase = m_rpc_r->getLastEv(); CPPUNIT_ASSERT( cmdBase != 0 ); const evRequestJoin* r_jreq = dynamic_cast<const evRequestJoin*>(cmdBase); CPPUNIT_ASSERT( rjoin == *r_jreq ); }
void display_whoami(session_t *s) { icq_private_t *j = s->priv; int uid = private_item_get_int(&j->whoami, "uid"); int end = 0; __displayed = 0; __display_info(s, META_BASIC_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_MORE_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_EMAIL_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_NOTES_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_HPAGECAT_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_WORK_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_INTERESTS_USERINFO, j->whoami); end |= __displayed; __displayed = 0; __display_info(s, META_AFFILATIONS_USERINFO, j->whoami); if (end) print("icq_userinfo_end", session_name(s), itoa(uid)); }
static int icq_meta_info_reply(session_t *s, unsigned char *buf, int len, private_data_t **info, int show) { /* SNAC(15,03)/07DA SRV_META_INFO_REPLY Meta information response * * This is the server response to client meta info request SNAC(15,02)/07D0. */ struct { uint16_t subtype; uint8_t result; unsigned char *data; } pkt; int userinfo = 0; metasnac_subhandler_t handler; if (!ICQ_UNPACK(&pkt.data, "wc", &pkt.subtype, &pkt.result)) { debug_error("icq_meta_info_reply() broken\n"); return -1; } debug_white("icq_meta_info_reply() subtype=%.4x result=%.2x (len=%d)\n", pkt.subtype, pkt.result, len); if ( (handler = get_userinfo_extension_handler(pkt.subtype)) ) { userinfo = 1; } else { switch (pkt.subtype) { /* search */ case SRV_LAST_USER_FOUND: handler = icq_snac_extension_userfound_last; break; case SRV_USER_FOUND: handler = icq_snac_extension_userfound; break; case META_SET_FULLINFO_ACK: handler = icq_snac_extension_fullinfo_ack; break; case SRV_RANDOM_FOUND: handler = NULL; break; /* XXX, SRV_RANDOM_FOUND */ default: handler = NULL; } } __displayed = 0; if (!handler) { debug_error("icq_meta_info_reply() ignored: %.4x\n", pkt.subtype); icq_hexdump(DEBUG_ERROR, pkt.data, len); return 0; } else { int uid = info ? private_item_get_int(info, "uid") : -1; debug_function("icq_snac_extensions_%s()", icq_lookuptable(meta_name, pkt.subtype)); if (userinfo) debug_function(" uid: %u", uid); debug_function("\n"); if (pkt.result == 0x0A) { handler(s, pkt.data, len, info); } else if (!userinfo){ /* Failed search */ debug_error("icq_snac_extension_userfound() search error: %u\n", pkt.result); } if (show) { __display_info(s, pkt.subtype, *info); if (__displayed) print("icq_userinfo_end", session_name(s), itoa(uid)); } } return 0; }
//virtual BOOL LLIMFloater::postBuild() { const LLUUID& other_party_id = LLIMModel::getInstance()->getOtherParticipantID(mSessionID); if (other_party_id.notNull()) { mOtherParticipantUUID = other_party_id; } mControlPanel->setSessionId(mSessionID); mControlPanel->getParent()->setVisible(gSavedSettings.getBOOL("IMShowControlPanel")); LLButton* slide_left = getChild<LLButton>("slide_left_btn"); slide_left->setVisible(mControlPanel->getParent()->getVisible()); slide_left->setClickedCallback(boost::bind(&LLIMFloater::onSlide, this)); LLButton* slide_right = getChild<LLButton>("slide_right_btn"); slide_right->setVisible(!mControlPanel->getParent()->getVisible()); slide_right->setClickedCallback(boost::bind(&LLIMFloater::onSlide, this)); mInputEditor = getChild<LLLineEditor>("chat_editor"); mInputEditor->setMaxTextLength(1023); // enable line history support for instant message bar mInputEditor->setEnableLineHistory(TRUE); // *TODO Establish LineEditor with autoreplace callback mInputEditor->setAutoreplaceCallback(boost::bind(&LLAutoReplace::autoreplaceCallback, LLAutoReplace::getInstance(), _1, _2)); LLFontGL* font = LLViewerChat::getChatFont(); mInputEditor->setFont(font); mInputEditor->setFocusReceivedCallback( boost::bind(onInputEditorFocusReceived, _1, this) ); mInputEditor->setFocusLostCallback( boost::bind(onInputEditorFocusLost, _1, this) ); mInputEditor->setKeystrokeCallback( onInputEditorKeystroke, this ); mInputEditor->setCommitOnFocusLost( FALSE ); mInputEditor->setRevertOnEsc( FALSE ); mInputEditor->setReplaceNewlinesWithSpaces( FALSE ); mInputEditor->setPassDelete( TRUE ); childSetCommitCallback("chat_editor", onSendMsg, this); mChatHistory = getChild<LLChatHistory>("chat_history"); setDocked(true); mTypingStart = LLTrans::getString("IM_typing_start_string"); // Disable input editor if session cannot accept text LLIMModel::LLIMSession* im_session = LLIMModel::instance().findIMSession(mSessionID); if( im_session && !im_session->mTextIMPossible ) { mInputEditor->setEnabled(FALSE); mInputEditor->setLabel(LLTrans::getString("IM_unavailable_text_label")); } if ( im_session && im_session->isP2PSessionType()) { // look up display name for window title LLAvatarNameCache::get(im_session->mOtherParticipantID, boost::bind(&LLIMFloater::onAvatarNameCache, this, _1, _2)); } else { std::string session_name(LLIMModel::instance().getName(mSessionID)); updateSessionName(session_name, session_name); } //*TODO if session is not initialized yet, add some sort of a warning message like "starting session...blablabla" //see LLFloaterIMPanel for how it is done (IB) if(isChatMultiTab()) { return LLFloater::postBuild(); } else { return LLDockableFloater::postBuild(); } }
static COMMAND(xmsg_msg) { char fn[sizeof(XMSG_TMPFILE_PATH)]; int fd; char *msg = (char*) params[1]; const char *uid; int fs; int n; const char *msgcmd = session_get(session, "send_cmd"); char *msgx = NULL, *mymsg; if (!(uid = get_uid(session, target))) { printq("invalid_session"); return -1; } if (!msgcmd || *msgcmd == '\0') { printq("xmsg_nosendcmd", session_name(session)); return -1; } xstrcpy(fn, XMSG_TMPFILE_PATH); fd = mkstemp(fn); if (fd == -1) xerrn("Unable to create temp file"); { const char *charset = session_get(session, "charset"); if (charset) msgx = ekg_convert_string(msg, NULL, charset); mymsg = (msgx ? msgx : msg); } fs = xstrlen(mymsg); while (fs > 0) { if ((n = write(fd, mymsg, fs)) == -1) { unlink(fn); close(fd); xfree(msgx); xerrn("Unable to write message into temp file"); } fs -= n; mymsg += n; } xfree(msgx); close(fd); if ((command_exec_format(NULL, session, 1, "!^%s \"%s\" \"%s\"", msgcmd, target+XMSG_UID_DIROFFSET, fn))) xerr("msgcmd exec failed"); { char **rcpts = xcalloc(2, sizeof(char *)); int class = (xstrcmp(name, "chat") ? EKG_MSGCLASS_SENT : EKG_MSGCLASS_SENT_CHAT); rcpts[0] = xstrdup(uid); rcpts[1] = NULL; protocol_message_emit(session, session->uid, rcpts, params[1], NULL, time(NULL), class, NULL, EKG_NO_BEEP, 0); array_free(rcpts); } return 0; }
static int xmsg_handle_file(session_t *s, const char *fn) { const int nounlink = !session_int_get(s, "unlink_sent"); const int utb = session_int_get(s, "unlink_toobig"); const int maxfs = session_int_get(s, "max_filesize"); const char *dfsuffix = session_get(s, "dotfile_suffix"); char *namesep = (char*) session_get(s, "name_separator"); char *dir; int dirlen; char *msg = NULL; int err, fs; time_t ft = 0; if (*fn == '.') /* we're skipping ALL dotfiles */ return -1; dir = (char*) xmsg_dirfix(session_uid_get(s)+XMSG_UID_DIROFFSET); dirlen = xstrlen(dir); /* first check if buffer is long enough to fit the whole path for dotfile */ if (strlcpy(dir+dirlen+1, fn, PATH_MAX-dirlen-2-xstrlen(dfsuffix)) >= PATH_MAX-dirlen-2-xstrlen(dfsuffix)) xerr("Buffer too small for: fn = %s, len(fn) = %d, dirlen = %d, dfsuffixlen = %d", fn, xstrlen(fn), dirlen, xstrlen(dfsuffix)); /* then fill in middle part of path */ dir[dirlen] = '/'; /* and take a much closer look the file */ xdebug("s = %s, d = %s, fn = %s", session_uid_get(s), dir, fn); if ((err = xmsg_checkoutfile(dir, &msg, &fs, &ft, maxfs))) { if (err == EFBIG) { print((utb ? "xmsg_toobigrm" : "xmsg_toobig"), fn, session_name(s)); if (utb) { unlink(dir); return -1; } /* else we need to create the dotfile first */ } else if (err != ENOENT && err != EINVAL) return -1; } else if (!nounlink && (utb == (err == EFBIG))) unlink(dir); /* here: dir = dotf */ memmove(dir+dirlen+2, dir+dirlen+1, xstrlen(dir) - dirlen); dir[dirlen+1] = '.'; xstrcpy(dir+xstrlen(dir), dfsuffix); /* we've already checked whether it fits */ { struct stat st; int r; if (nounlink || !utb) { r = !(stat(dir, &st) || S_ISDIR(st.st_mode)); } else r = 0; if (err == ENOENT) { if (r) /* clean up stale dotfile */ unlink(dir); xfree(msg); return -1; } else if (r) { xfree(msg); /* XXX: I think that we rather shouldn't first read, then check if it is needed, at least for nounlink mode */ return -1; } else if ((nounlink && !(utb && err == EFBIG)) || (!utb && err == EFBIG)) close(open(dir, O_WRONLY|O_CREAT|O_TRUNC|O_NOFOLLOW, 0600)); } if (err == EFBIG) return -1; else if (err == EINVAL) xdebug("empty file, not submitting"); else { char *uid = xmalloc(strlen(fn) + 6); char *msgx = NULL; { const char *charset = session_get(s, "charset"); if (charset && (msgx = ekg_convert_string(msg, charset, NULL))) xfree(msg); else msgx = msg; } xstrcpy(uid, "xmsg:"); xstrcat(uid, fn); if (namesep) { char *p, *q = NULL; for (p = namesep; *p; p++) { char *r = xstrrchr(uid+XMSG_UID_DIROFFSET, *p); if (r > q) q = r; } if (q) *q = '\0'; } protocol_message_emit(s, uid, NULL, msgx, NULL, ft, EKG_MSGCLASS_CHAT, NULL, EKG_TRY_BEEP, 0); xfree(msgx); xfree(uid); } return 0; }
static COMMAND(sniff_command_connect) { struct bpf_program fp; char errbuf[PCAP_ERRBUF_SIZE] = { 0 }; pcap_t *dev; const char *filter; char *device; char *tmp; filter = session_get(session, "filter"); if (session_connected_get(session)) { printq("already_connected", session_name(session)); return -1; } if (session->uid[6] != '/') { if ((tmp = xstrchr(session->uid+6, ':'))) device = xstrndup(session->uid+6, tmp-(session->uid+6)); else device = xstrdup(session->uid+6); dev = pcap_open_live(device, SNAPLEN, PROMISC, 1000, errbuf); } else { device = xstrdup(session->uid+6); dev = pcap_open_offline(device, errbuf); } if (!dev) { debug_error("Couldn't open dev: %s (%s)\n", device, errbuf); printq("conn_failed", errbuf, session_name(session)); xfree(device); return -1; } if (pcap_setnonblock(dev, 1, errbuf) == -1) { debug_error("Could not set device \"%s\" to non-blocking: %s\n", device, errbuf); pcap_close(dev); xfree(device); return -1; } xfree(device); if (filter && *filter) { if (pcap_compile(dev, &fp, (char *) filter, 0, 0 /*net*/) == -1) { debug_error("Couldn't parse filter %s: %s\n", filter, pcap_geterr(dev)); pcap_close(dev); return -1; } if (pcap_setfilter(dev, &fp) == -1) { debug_error("Couldn't install filter %s: %s\n", filter, pcap_geterr(dev)); pcap_close(dev); return -1; } /* pcap_freecode(&fp); */ } session->priv = dev; switch (pcap_datalink(dev)) { case DLT_LINUX_SLL: watch_add_session(session, pcap_fileno(dev), WATCH_READ, sniff_pcap_read_SLL); break; case DLT_EN10MB: watch_add_session(session, pcap_fileno(dev), WATCH_READ, sniff_pcap_read_EN10MB); break; default: debug_error("_connect() unk: %s\n", pcap_datalink_val_to_name(pcap_datalink(dev))); watch_add_session(session, pcap_fileno(dev), WATCH_READ, sniff_pcap_read); } session->status = EKG_STATUS_AVAIL; protocol_connected_emit(session); return 0; }