/* 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 WATCHER(xmsg_handle_data)
{
int n;
int c = 0;
struct inotify_event *evp;
if (type)
return -1;
ioctl(fd, FIONREAD, &n);
if (n == 0)
return 0;
ev = xrealloc(ev, n);
n = read(fd, ev, n);
if (n < 0)
xerrn("inotify read() failed");
for (evp = ev; n > 0; n -= (evp->len + sizeof(struct inotify_event)), evp = (void*) evp + (evp->len + sizeof(struct inotify_event))) {
session_t *s;
for (s = sessions; s; s = s->next) {
if (s && (s->priv == (void*) (long int) evp->wd) && (s->plugin == &xmsg_plugin))
break;
}
xdebug("n = %d, wd = %d, str = %s", n, evp->wd, evp->name);
if ((evp->mask & IN_IGNORED) || !s || !session_connected_get(s))
continue;
else if (evp->mask & IN_UNMOUNT)
xmsg_disconnect(NULL, NULL, s, NULL, -1);
else if (!(evp->mask & IN_Q_OVERFLOW) && (c != -1) && (!xmsg_handle_file(s, evp->name)))
c++;
if ((evp->mask & IN_Q_OVERFLOW) || ((config_maxinotifycount > 0) && c >= config_maxinotifycount)) {
for (s = sessions; s; s = s->next) {
if (s && (s->plugin == &xmsg_plugin)) {
const int i = session_int_get(s, "oneshot_resume_timer");
if (!timer_remove_session(s, "o"))
xdebug("old oneshot resume timer removed");
if ((i > 0) && timer_add_session(s, "o", i, 0, xmsg_iterate_dir)) {
xdebug("oneshot resume timer added");
session_status_set(s, EKG_STATUS_AWAY);
} else
session_status_set(s, EKG_STATUS_AVAIL);
c = -1;
}
}
}
}
if (c >= 0)
xdebug("processed %d files", c);
else
xdebug("reached max_inotifycount");
return 0;
}
static COMMAND(xmsg_reconnect)
{
if (session_connected_get(session)) {
xmsg_disconnect(name, params, session, target, quiet);
}
return xmsg_connect(name, params, session, target, quiet);
}
PyObject *ekg_session_connected(ekg_sessionObj * self)
{
session_t * s;
s = session_find(self->name);
debug("[python] Checking if session %s is connected\n", self->name);
if (session_connected_get(s)) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
static void xmsg_timer_change(session_t *s, const char *varname)
{
int n = (varname ? session_int_get(s, varname) : 0);
xdebug("n = %d", n);
if (!varname || session_connected_get(s)) {
if (!timer_remove_session(s, "w"))
xdebug("old timer removed");
if (n > 0) {
if (timer_add_session(s, "w", n, 1, xmsg_iterate_dir))
xdebug("new timer added");
}
}
}
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;
}
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 TIMER_SESSION(xmsg_iterate_dir)
{
const char *dir;
DIR *d;
struct dirent *de;
int n = 0;
const int maxn = session_int_get(s, "max_oneshot_files");
if (type || !s || !session_connected_get(s))
return -1;
session_status_set(s, EKG_STATUS_AVAIL);
if (!(dir = xmsg_dirfix(session_uid_get(s)+XMSG_UID_DIROFFSET))
|| !(d = opendir(dir))) {
xerr("unable to open specified directory");
return 0;
}
while ((de = readdir(d))) {
if (!xmsg_handle_file(s, de->d_name))
n++;
if ((maxn > 0) && n >= maxn) {
const int i = session_int_get(s, "oneshot_resume_timer");
if ((i > 0) && timer_add_session(s, "o", i, 0, xmsg_iterate_dir))
xdebug("oneshot resume timer added");
session_status_set(s, EKG_STATUS_AWAY);
break;
}
}
closedir(d);
xdebug("processed %d files", n);
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;
}
