int usb_set_altinterface(usb_dev_handle *dev, int alternate)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Prepare packet
pkt_init(pkt, UsbSetAltInterface);
pkt_addint(pkt, dev->fd);
pkt_addint(pkt, alternate);
pkt_send(pkt, fd);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbSetAltInterface) {
Iterator it;
pkt_begin(pkt, &it);
// Read result
res = iter_getint(&it);
// Read callback configuration
alternate = iter_getint(&it);
}
// Save configuration
dev->altsetting = alternate;
// Return response
pkt_release();
debug_msg("returned %d", res);
return res;
}
/*
* logs_session_var_changed()
*
* "session-variable-changed" handler
*/
static QUERY(logs_session_var_changed) {
char *session = *(va_arg(ap, char**));
char *var = *(va_arg(ap, char**));
int i;
if (!logs_logs || (0 == logs_logs->len))
return 0;
if (!xstrcmp(var, "log_formats")) {
session_t *s = session_find(session);
int newformat = logs_log_format(s);
debug_function("logs_session_var_changed() s=%s, %s=%s\n", session, var, session_get(s, var));
for (i = logs_logs->len - 1; 0 <= i; i--) {
logs_log_t *ll = g_ptr_array_index(logs_logs, i);
if (LOG_FORMAT_RAW == ll->format) continue;
if (xstrcmp(ll->session, session)) continue;
if (ll->format != newformat)
logs_log_reopen(ll);
}
}
return 0;
}
/* libusb(5):
* Interrupt transfers.
*/
int usb_interrupt_write(usb_dev_handle *dev, int ep, usb_buf_t bytes, int size, int timeout)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Prepare packet
pkt_init(pkt, UsbInterruptWrite);
pkt_addint(pkt, dev->fd);
pkt_addint(pkt, ep);
pkt_addstr(pkt, size, bytes);
pkt_addint(pkt, timeout);
pkt_send(pkt, fd);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbInterruptWrite) {
Iterator it;
pkt_begin(pkt, &it);
res = iter_getint(&it);
}
// Return response
pkt_release();
debug_msg("returned %d", res);
return res;
}
int usb_close(usb_dev_handle *dev)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Send packet
pkt_init(pkt, UsbClose);
pkt_addint(pkt, dev->fd);
pkt_send(pkt, fd);
// Free device
free(dev);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbClose) {
Iterator it;
pkt_begin(pkt, &it);
res = iter_getint(&it);
}
pkt_release();
debug_msg("returned %d", res);
return res;
}
static void
ct_session_close (u32 ct_index, u32 thread_index)
{
ct_connection_t *ct, *peer_ct;
app_worker_t *app_wrk;
session_t *s;
ct = ct_connection_get (ct_index);
peer_ct = ct_connection_get (ct->peer_index);
if (peer_ct)
{
peer_ct->peer_index = ~0;
session_transport_closing_notify (&peer_ct->connection);
}
s = session_get (ct->c_s_index, 0);
app_wrk = app_worker_get_if_valid (s->app_wrk_index);
if (app_wrk)
app_worker_del_segment_notify (app_wrk, ct->segment_handle);
session_free_w_fifos (s);
if (ct->is_client)
segment_manager_dealloc_fifos (ct->client_rx_fifo, ct->client_tx_fifo);
ct_connection_free (ct);
ct_enable_disable_main_pre_input_node (0 /* is_add */ );
}
int usb_get_driver_np(usb_dev_handle *dev, int interface, char *name, unsigned int namelen)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Send packet
pkt_init(pkt, UsbGetKernelDriver);
pkt_addint(pkt, dev->fd);
pkt_addint(pkt, interface);
pkt_adduint(pkt, namelen);
pkt_send(pkt, fd);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbGetKernelDriver) {
Iterator it;
pkt_begin(pkt, &it);
res = iter_getint(&it);
// Error
if(res) {
error_msg("%s: could not get bound driver", __func__);
}
// Save string
strncpy(name, iter_getstr(&it), namelen - 1);
name[namelen - 1] = '\0';
}
pkt_release();
debug_msg("returned %d (%s)", res, name);
return res;
}
int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Prepare packet
pkt_init(pkt, UsbInterruptRead);
pkt_addint(pkt, dev->fd);
pkt_addint(pkt, ep);
pkt_addint(pkt, size);
pkt_addint(pkt, timeout);
pkt_send(pkt, fd);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbInterruptRead) {
Iterator it;
pkt_begin(pkt, &it);
res = iter_getint(&it);
if(res > 0) {
int minlen = (res > size) ? size : res;
memcpy(bytes, it.val, minlen);
}
}
// Return response
pkt_release();
debug_msg("returned %d", res);
return res;
}
int
session_tx_fifo_peek_bytes (transport_connection_t * tc, u8 * buffer,
u32 offset, u32 max_bytes)
{
session_t *s = session_get (tc->s_index, tc->thread_index);
return svm_fifo_peek (s->tx_fifo, offset, max_bytes, buffer);
}
int s_lock (IncomingRequest *inc_request)
{
FsResponse response;
FsLockC data_c = inc_request->request.data.lock;
int server_handler = data_c.server_handler;
int fd = data_c.fd;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.lock.status = -1;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
int file = session_get (server_handler, fd);
if (file == -1)
{
VDP0 ("Could not get file descriptor in lock\n");
response.data.lock.status = -1;
}
else
{
// @todo ustawiamy flocka jedynie gdy chcemy czytac cos po kryjomu
response.data.lock.status = flock(file, data_c.mode);
}
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
int s_lseek (IncomingRequest *inc_request)
{
FsResponse response;
FsLseekC data_c = inc_request->request.data.lseek;
int server_handler = data_c.server_handler;
int fd = data_c.fd;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.lseek.status = -1;
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
int file = session_get (server_handler, fd);
if (file == -1)
{
VDP0 ("Could not get file descriptor in lseek\n");
response.data.lseek.status = -1;
}
else
{
off_t offset = lseek (file, data_c.offset, data_c.whence);
if (offset < 0) offset = 0;
off_t status = session_set_offset (server_handler, fd, offset);
if (status < 0) response.answer = EF_ACCESS_ERROR;
response.data.lseek.status = status;
}
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
usb_dev_handle *usb_open(struct usb_device *dev)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Send packet
pkt_init(pkt, UsbOpen);
pkt_adduint(pkt, dev->bus->location);
pkt_adduint(pkt, dev->devnum);
pkt_send(pkt, fd);
// Get response
int res = -1, devfd = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbOpen) {
Iterator it;
pkt_begin(pkt, &it);
res = iter_getint(&it);
devfd = iter_getint(&it);
}
// Evaluate
usb_dev_handle* udev = NULL;
if(res >= 0) {
udev = malloc(sizeof(usb_dev_handle));
udev->fd = devfd;
udev->device = dev;
udev->bus = dev->bus;
udev->config = udev->interface = udev->altsetting = -1;
}
pkt_release();
debug_msg("returned %d (fd %d)", res, devfd);
return udev;
}
int usb_reset(usb_dev_handle *dev)
{
// Get remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Prepare packet
pkt_init(pkt, UsbReset);
pkt_addint(pkt, dev->fd);
pkt_send(pkt, fd);
// Get response
int res = -1;
if(pkt_recv(fd, pkt) > 0 && pkt_op(pkt) == UsbReset) {
Iterator it;
pkt_begin(pkt, &it);
// Read result
res = iter_getint(&it);
}
// Return response
pkt_release();
debug_msg("returned %d", res);
return res;
}
session_t *
ct_session_get_peer (session_t * s)
{
ct_connection_t *ct, *peer_ct;
ct = ct_connection_get (s->connection_index);
peer_ct = ct_connection_get (ct->peer_index);
return session_get (peer_ct->c_s_index, 0);
}
/* Check if we have data waiting. */
NBBOOL session_data_waiting(sessions_t *sessions, char *session_name)
{
session_t *session = session_get(sessions, session_name);
if(!session)
return FALSE;
return buffer_can_read_int8(session->buffer) || buffer_can_read_int8(sessions->buffer_data);
}
uint32_t session_get_seq(sessions_t *sessions, char *session_name)
{
session_t *session = session_get(sessions, session_name);
if(!session)
return -1;
session->seq = session->seq + 1;
return session->seq;
}
u32
session_tx_fifo_dequeue_drop (transport_connection_t * tc, u32 max_bytes)
{
session_t *s = session_get (tc->s_index, tc->thread_index);
if (svm_fifo_needs_tx_ntf (s->tx_fifo, max_bytes))
session_dequeue_notify (s);
return svm_fifo_dequeue_drop (s->tx_fifo, max_bytes);
}
/* This is the "front door" for data coming into the session through
* stdin. When data arrives on stdin, the data should be passed to this
* function. If the session is actually using stdin for input, this will
* be read and, more then likely, come back out a session_read() call.
*/
static void session_feed(sessions_t *sessions, char *name, uint8_t *data, uint32_t length)
{
session_t *session = session_get(sessions, name);
if(!session)
{
fprintf(stderr, "Session not found: %s\n", name);
return;
}
buffer_add_bytes(session->buffer, data, length);
}
/*
* Enqueue data for delivery to session peer. Does not notify peer of enqueue
* event but on request can queue notification events for later delivery by
* calling stream_server_flush_enqueue_events().
*
* @param tc Transport connection which is to be enqueued data
* @param b Buffer to be enqueued
* @param offset Offset at which to start enqueueing if out-of-order
* @param queue_event Flag to indicate if peer is to be notified or if event
* is to be queued. The former is useful when more data is
* enqueued and only one event is to be generated.
* @param is_in_order Flag to indicate if data is in order
* @return Number of bytes enqueued or a negative value if enqueueing failed.
*/
int
session_enqueue_stream_connection (transport_connection_t * tc,
vlib_buffer_t * b, u32 offset,
u8 queue_event, u8 is_in_order)
{
session_t *s;
int enqueued = 0, rv, in_order_off;
s = session_get (tc->s_index, tc->thread_index);
if (is_in_order)
{
enqueued = svm_fifo_enqueue (s->rx_fifo,
b->current_length,
vlib_buffer_get_current (b));
if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT)
&& enqueued >= 0))
{
in_order_off = enqueued > b->current_length ? enqueued : 0;
rv = session_enqueue_chain_tail (s, b, in_order_off, 1);
if (rv > 0)
enqueued += rv;
}
}
else
{
rv = svm_fifo_enqueue_with_offset (s->rx_fifo, offset,
b->current_length,
vlib_buffer_get_current (b));
if (PREDICT_FALSE ((b->flags & VLIB_BUFFER_NEXT_PRESENT) && !rv))
session_enqueue_chain_tail (s, b, offset + b->current_length, 0);
/* if something was enqueued, report even this as success for ooo
* segment handling */
return rv;
}
if (queue_event)
{
/* Queue RX event on this fifo. Eventually these will need to be flushed
* by calling stream_server_flush_enqueue_events () */
session_worker_t *wrk;
wrk = session_main_get_worker (s->thread_index);
if (!(s->flags & SESSION_F_RX_EVT))
{
s->flags |= SESSION_F_RX_EVT;
vec_add1 (wrk->session_to_enqueue[tc->proto], s->session_index);
}
}
return enqueued;
}
NBBOOL session_is_closed(sessions_t *sessions, char *session_name)
{
session_t *session;
session = session_get(sessions, session_name);
if(!session)
return FALSE;
if(session->is_eof && !session_data_waiting(sessions, session_name))
return TRUE;
return FALSE;
}
/** Initialize USB subsystem. */
void usb_init(void)
{
// Initialize packet & remote fd
Packet* pkt = pkt_claim();
int fd = session_get();
// Create buffer
pkt_init(pkt, UsbInit);
pkt_send(pkt, fd);
pkt_release();
// Initialize locally
debug_msg("called");
}
/* kind = 0 for sent, 1 for toobig */
static void xmsg_unlink_dotfiles(session_t *s, const char *varname)
{
if (session_int_get(s, varname)) {
const int kind = !xstrcasecmp(varname, "unlink_sent");
const int maxfs = session_int_get(s, "max_filesize");
const char *dfsuffix = session_get(s, "dotfile_suffix");
const char *dir = xmsg_dirfix(session_uid_get(s)+XMSG_UID_DIROFFSET);
DIR *d;
struct dirent *de;
struct stat st, std;
char *df, *dfd, *dp, *dpd;
if (!dir || !(d = opendir(dir))) {
xdebug("unable to open specified directory");
return;
}
df = xmalloc(xstrlen(dir) + NAME_MAX + 2);
dfd = xmalloc(xstrlen(dir) + NAME_MAX + 3 + xstrlen(dfsuffix));
xstrcpy(df, dir);
dp = df + xstrlen(df);
*(dp++) = '/';
xstrcpy(dfd, df);
dpd = dfd + xstrlen(dfd);
*(dpd++) = '.';
while ((de = readdir(d))) {
if (de->d_name[0] == '.')
continue;
if (xstrlen(de->d_name) > NAME_MAX) {
xdebug2(DEBUG_ERROR, "Filename longer than NAME_MAX (%s), skipping.", de->d_name);
continue;
}
xstrcpy(dp, de->d_name);
xstrcpy(dpd, de->d_name);
xstrcat(dpd, dfsuffix);
if (!stat(df, &st) && !stat(dfd, &std)
&& ((!maxfs || (st.st_size < maxfs)) == kind)) {
xdebug("removing %s", de->d_name);
unlink(df);
unlink(dfd);
}
}
closedir(d);
xfree(df);
xfree(dfd);
}
}
int cgiMain() {
int result;
#ifdef DEBUG
fprintf(stderr, "========== LED.CGI Start ===========.\n");
#endif
// 初始化 session
session_start(g_session_datadir);
do {
if (session_get("USERNAME") != NULL) {
if (strcmp(session_get("USERNAME"), g_login_username) == 0) {
result = control_process();
break;
}
}
result = login_process();
} while (0);
#ifdef DEBUG
fprintf(cgiOut, "========== LED.CGI End ===========.\n");
#endif
return result;
}
void session_initialize(sessions_t *sessions, char *session_name, uint32_t seq)
{
if(!session_get(sessions, session_name))
{
session_t *session;
fprintf(stderr, "Creating new session %s with sequence number %d\n", session_name, seq);
session = session_create(sessions, session_name, seq);
/* If we're in exec mode, attach the process. */
/* TODO: This is likely where I'll bind it to a socket. */
if(sessions->exec)
{
session_attach_process(sessions, session, sessions->exec);
}
}
}
PyObject *ekg_session_get(ekg_sessionObj * self, PyObject * key)
{
const char * name = PyString_AsString(key);
const char * out;
char buf[100];
session_t * s;
s = session_find(self->name);
debug("[python] Getting '%s' value for '%s' session\n", name, self->name);
out = session_get(s, name);
if (out) {
return Py_BuildValue("s", out);
} else {
snprintf(buf, 99, "Can't find variable '%s'", name);
PyErr_SetString(PyExc_KeyError, buf);
Py_INCREF(Py_None);
return Py_None;
}
}
static int logs_log_format(session_t *s) {
const char *log_formats;
if (config_logs_log == LOG_FORMAT_NONE)
return LOG_FORMAT_NONE;
if (!s || !(log_formats = session_get(s, "log_formats")))
return LOG_FORMAT_NONE;
if (xstrstr(log_formats, "irssi"))
return LOG_FORMAT_IRSSI;
if (config_logs_log == LOG_FORMAT_SIMPLE && xstrstr(log_formats, "simple"))
return LOG_FORMAT_SIMPLE;
if (config_logs_log == LOG_FORMAT_XML && xstrstr(log_formats, "xml"))
return LOG_FORMAT_XML;
return LOG_FORMAT_NONE;
}
static void exec_asp( connection* conn )
{
char key[20];
key[16] = '\0';
cookie_get( conn, "SESSIONKEY", key, 16 );
conn->session = session_get( conn->client, key );
if( !conn->session ){
conn->code = 500;
}else{
if( !(*key) || strcmp( conn->session->key, key ) != 0 )
cookie_set( conn, "SESSIONKEY", "/", -1, conn->session->key );
NEW( conn->data_send, MAX_DATASEND+4 );
conn->data_size = 0;
if( vdir_exec( conn->server, conn->current_dir, conn ) < 0 ){
conn->code = 404;
}
if( !conn->data_size )
conn->data_size = strlen( conn->data_send );
}
}
/* Read data from the session that will be sent out across the network. This
* will return up to read_length bytes (and will return the number of bytes
* read in read_length as well). The memory returned has to be freed.
*
* If the session isn't found, NULL is returned. If no data is waiting, the
* empty string is returned and read_length is set to 0.
*/
uint8_t *session_read(sessions_t *sessions, char *session_name, uint32_t *read_length)
{
uint32_t i = 0;
buffer_t *incoming;
buffer_t *response;
session_t *session;
session = session_get(sessions, session_name);
if(!session)
return NULL;
if(session_is_closed(sessions, session_name))
return NULL;
if(buffer_can_read_int8(sessions->buffer_data))
{
incoming = sessions->buffer_data;
}
else
{
if(!session)
return NULL;
incoming = session->buffer;
}
response = buffer_create(BO_NETWORK);
while(buffer_can_read_int8(incoming) && i < *read_length)
{
if(sessions->log)
fputc(buffer_peek_next_int8(incoming), sessions->log);
buffer_add_int8(response, buffer_read_next_int8(incoming));
i++;
}
/* Clear whichever buffer we're using if we're at the end. */
if(!buffer_can_read_int8(incoming))
buffer_clear(incoming);
return buffer_create_string_and_destroy(response, read_length);
}
NBBOOL session_validate_seq(sessions_t *sessions, char *name, uint32_t seq, NBBOOL do_increment)
{
session_t *session = session_get(sessions, name);
if(!session)
{
fprintf(stderr, "Session %s doesn't exist; accepting sequence number %d\n", name, seq);
return TRUE;
}
/* Note: we have to validate against the next sequence number. */
if(seq != session->seq + (do_increment ? 1 : 0))
{
fprintf(stderr, "Failed to validate sequence number for session %s (sequence should be %d, was %d)\n", name, session->seq, seq);
return FALSE;
}
if(do_increment)
session->seq = session->seq + 1;
return TRUE;
}
bool test_tcp_closed_state_handle_6( void )
{
struct sk_buff *skb;
struct session_entry *session;
struct tuple tuple;
bool success = true;
if (!init_tuple_for_test_ipv6( &tuple, IPPROTO_TCP ))
return false;
if (!(skb = init_packet_type_for_test( PACKET_TYPE_V6_SYN )))
return false;
success &= assert_true(tcp_closed_state_handle( skb, &tuple ), "V6 syn-result");
session = session_get( &tuple );
success &= assert_not_null(session, "V6 syn-session.");
if (session)
success &= assert_equals_u8(V6_INIT, session->state, "V6 syn-state");
kfree_skb(skb);
return success;
}
static DBusMessage *sync_getphonebook(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct session_data *session = user_data;
struct sync_data *syncdata = session_get_data(session);
if (session->msg)
return g_dbus_create_error(message,
ERROR_INF ".InProgress", "Transfer in progress");
/* set default phonebook_path to memory internal phonebook */
if (!syncdata->phonebook_path)
syncdata->phonebook_path = g_strdup("telecom/pb.vcf");
if (session_get(session, "phonebook", syncdata->phonebook_path, NULL,
NULL, 0, sync_getphonebook_callback) < 0)
return g_dbus_create_error(message,
ERROR_INF ".Failed", "Failed");
session->msg = dbus_message_ref(message);
return NULL;
}
