void client::info(server_info & out) { send_(makecmd("INFO", true)); string response = recv_bulk_reply_(); if (response.empty()) throw protocol_error("empty"); string_vector lines; split_lines(response, lines); if (lines.empty()) throw protocol_error("empty line for info"); for (string_vector::const_iterator it = lines.begin(); it != lines.end(); ++it) { const string & line = *it; string_vector line_parts; split(line, ':', line_parts); if (line_parts.size() != 2) throw protocol_error("unexpected line format for info"); const string & key = line_parts[0]; const string & val = line_parts[1]; if (key == server_info_key_version) out.version = val; else if (key == server_info_key_bgsave_in_progress) out.bgsave_in_progress = value_from_string<unsigned long>(val) == 1; else if (key == server_info_key_connected_clients) out.connected_clients = value_from_string<unsigned long>(val); else if (key == server_info_key_connected_slaves) out.connected_slaves = value_from_string<unsigned long>(val); else if (key == server_info_key_used_memory) out.used_memory = value_from_string<unsigned long>(val); else if (key == server_info_key_changes_since_last_save) out.changes_since_last_save = value_from_string<unsigned long>(val); else if (key == server_info_key_last_save_time) out.last_save_time = value_from_string<unsigned long>(val); else if (key == server_info_key_total_connections_received) out.total_connections_received = value_from_string<unsigned long>(val); else if (key == server_info_key_total_commands_processed) out.total_commands_processed = value_from_string<unsigned long>(val); else if (key == server_info_key_uptime_in_seconds) out.uptime_in_seconds = value_from_string<unsigned long>(val); else if (key == server_info_key_uptime_in_days) out.uptime_in_days = value_from_string<unsigned long>(val); else if (key == server_info_key_role) out.role = val == server_info_value_role_master ? role_master : role_slave; else throw protocol_error(string("unexpected info key '") + key + "'"); } }
void P2PFolder::handle_message(const blob& message_raw) { V1Parser::message_type message_type = parser_.parse_MessageType(message_raw); counter_.add_down(message_raw.size()); if(ready()) { switch(message_type) { case V1Parser::CHOKE: handle_Choke(message_raw); break; case V1Parser::UNCHOKE: handle_Unchoke(message_raw); break; case V1Parser::INTERESTED: handle_Interested(message_raw); break; case V1Parser::NOT_INTERESTED: handle_NotInterested(message_raw); break; case V1Parser::HAVE_META: handle_HaveMeta(message_raw); break; case V1Parser::HAVE_CHUNK: handle_HaveChunk(message_raw); break; case V1Parser::META_REQUEST: handle_MetaRequest(message_raw); break; case V1Parser::META_REPLY: handle_MetaReply(message_raw); break; case V1Parser::META_CANCEL: handle_MetaCancel(message_raw); break; case V1Parser::BLOCK_REQUEST: handle_BlockRequest(message_raw); break; case V1Parser::BLOCK_REPLY: handle_BlockReply(message_raw); break; case V1Parser::BLOCK_CANCEL: handle_BlockCancel(message_raw); break; default: throw protocol_error(); } }else{ handle_Handshake(message_raw); } }
/** * Common function to handle parsing the HTTP stream for both v0 and v1 io * implementations. */ static void read_common(http_provider *http) { lcb_error_t err; lcb_connection_t conn = &http->connection; int old_generation = http->stream.generation; lcb_log(LOGARGS(http, TRACE), "Received %d bytes on HTTP stream", conn->input->nbytes); lcb_timer_rearm(http->io_timer, PROVIDER_SETTING(&http->base, config_node_timeout)); lcb_string_rbappend(&http->stream.chunk, conn->input, 1); err = htvb_parse(&http->stream, http->base.parent->settings->conntype); if (http->stream.generation != old_generation) { lcb_log(LOGARGS(http, DEBUG), "Generation %d -> %d", old_generation, http->stream.generation); set_new_config(http); } else { lcb_log(LOGARGS(http, TRACE), "HTTP not yet done. Err=0x%x", err); } if (err != LCB_BUSY && err != LCB_SUCCESS) { protocol_error(http, err); return; } lcb_sockrw_set_want(conn, LCB_READ_EVENT, 1); lcb_sockrw_apply_want(conn); }
client::int_type client::recv_int_reply_() { string line = read_line(socket_); #ifndef NDEBUG output_proto_debug(line); #endif if (line.empty()) throw protocol_error("invalid integer reply; empty"); if (line[0] != prefix_int_reply) throw protocol_error("unexpected prefix for integer reply"); return value_from_string<client::int_type>(line.substr(1)); }
void peer::on_state(readable& in) { state_msg state; in(state); vector<digest> options(2); options.push_back(state.top_digest); options.push_back(state.prev_digest); in.read_full(options, k_max_state_depth); m_top_digest = state.top_digest; m_top_work = state.top_work; m_top_height = state.top_height; m_top_txn = std::numeric_limits<uint64_t>::max(); m_ssync_txn = 0; tx_queue_t empty; std::swap(m_txns, empty); // Find first point to merge bool worked = false; for(uint64_t i = 0; i < options.size(); i++) { chain_ptr p = chain::find_by_digest(options[i]); if (p) { m_head = p; worked = true; break; } } if (!worked) { throw protocol_error("State never reached shared node"); } }
void P2PFolder::perform_handshake() { if(!folder_group()) throw protocol_error(); V1Parser::Handshake message_struct; message_struct.auth_token = local_token(); message_struct.device_name = Config::get()->globals()["client_name"].asString(); message_struct.user_agent = Version::current().user_agent(); send_message(parser_.gen_Handshake(message_struct)); log_->debug() << log_tag() << "==> HANDSHAKE"; }
unsigned char get_8( void ) { int x; x = fgetc( server_r ); if (x == EOF) { protocol_error(); } /*printf( "RECV %02x\n", x );*/ return x; }
void peer::on_chain(const chain_request& cr, readable& in) { m_req_count--; vector<block_ext> bes; in.read_full(bes, k_max_chain_req, 1); for(uint64_t i = 0; i < bes.size(); i++) { chain_ptr nh = m_head->append(bes[i].details, bes[i].nonce); auto wr = work_requirements(m_head); if (nh->self_work() < wr.second) { throw protocol_error("Insufficent work in chain response"); } if (nh->height() > m_top_height) { throw protocol_error("Height larger than expected in chain response"); } m_head = nh; } if (m_head->height() == m_top_height) { if (m_top_work != m_head->total_work() || m_top_digest != m_head->self_digest()) { throw protocol_error("Top of chain failed to match"); } } }
client::int_type client::recv_bulk_reply_(char prefix) { string line = read_line(socket_); // cout<<"line:"<<line<<endl; #ifndef NDEBUG output_proto_debug(line); #endif if (line[0] != prefix) { throw protocol_error("unexpected prefix for bulk reply"); } return value_from_string<client::int_type>(line.substr(1)); }
string client::recv_single_line_reply_() { string line = read_line(socket_); #ifndef NDEBUG output_proto_debug(line); #endif if (line.empty()) throw protocol_error("empty single line reply"); if (line.find(prefix_status_reply_error) == 0) { string error_msg = line.substr(prefix_status_reply_error.length()); if (error_msg.empty()) error_msg = "unknown error"; throw protocol_error(error_msg); } if (line[0] != prefix_status_reply_value) throw protocol_error("unexpected prefix for status reply"); return line.substr(1); }
void peer::on_txd(const digest& block, const digest& txn, readable& in) { if (block != m_head->self_digest()) { return; // Looks like I've moved on } if (m_head != m_server.top()) { return; // Looks like the server has moved on } txn_pow pow; in(pow); if (txn != digest(pow.txn)) { throw protocol_error("Txn digest does not match txn"); } m_server.build_block()->apply_remote_txn(pow); }
void peer::on_message(readable& in) { resp_type rt; in(rt); if (rt == resp_type::state) { on_state(in); return; } if (rt != resp_type::success && rt != resp_type::ood) { throw protocol_error("Invalid response type"); } auto p = std::move(m_queue.front()); m_queue.pop(); if (rt == resp_type::success) { p.first(in); } else { p.second(); } }
/* Handle session start information */ gchar * get_session_info (gint out, gchar *code) { gchar *buffer; gchar *retval; buffer = read_code (out); if (!strcmp (buffer, code)) { flush_buffer (buffer); buffer = read_line (out); retval = get_info_after_colon (buffer); g_free (buffer); return retval; } g_warning ("Waiting for %s, got %s\n", code, buffer); protocol_error ("session info!"); return NULL; }
/** handshake - accept incoming connection */ static int accept_connection(ICI *d, char **remotehost, unsigned short *rport) { struct sockaddr_in addr; int s; socklen_t addrlen = sizeof(addr); debugmsg(DEBUG_SRV, "SRV: waiting for accept on server-fd:%d\n", d->fd); do { s = accept(d->fd, (struct sockaddr *)&addr, &addrlen); } while(s < 0 && errno == EINTR); *remotehost = inet_ntoa(addr.sin_addr); *rport = ntohs(addr.sin_port); if(s<0) { dlog(DLOG_WARNING, "SRV: socket accept error: %s\n", strerror(errno)); return (-1); } dlog(DLOG_INFO, "SRV: Connection accepted %s:%d\n", *remotehost, *rport); // pthread_mutex_lock(&d->lock); ? not needed if (d->num_clients >= MAXCONNECTIONS) { protocol_error(s, 503, "Too many open connections. Please try again later."); #ifndef HAVE_WINDOWS close(s); #else closesocket(s); #endif dlog(DLOG_WARNING, "SRV: refused client. max number of connections (%i) readed.\n", MAXCONNECTIONS); return (-1); } // check if we should use SO_KEEPALIVE here //int val = 1; setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(int)); // or set non-blocking i/o ... //setnonblock(s, 1); return(s); }
void ptree::read(readable& in) { vector<ptree_ptr> stack; vector<uint8_t> split_stack; uint8_t max_byte = std::numeric_limits<uint8_t>::max(); stack.reserve(k_max_ptree_proof_stack); split_stack.reserve(k_max_ptree_proof_stack); // Loop exits on valid EOF marker or when read throws due to EOF while(1) { if (stack.size() == k_max_ptree_proof_stack) { // To use 256 elements of the stack requires a depth of 128, which // basically means SHA256 is broken... throw protocol_error("Stack impossibly large in ptree"); } uint8_t type; in.read_full(type); if (type == pid_eof) { // We are done, leave loop and validate break; } else if (type == pid_leaf) { // Read a leaf + push to stack ptree_ptr p = make_shared<ptree_leaf>(in); stack.push_back(p); split_stack.push_back(max_byte); } else if (type == pid_proxy) { // Read a proxy + push to stack ptree_ptr p = make_shared<ptree_proxy>(in); stack.push_back(p); split_stack.push_back(max_byte); } else { // Construct a branch // First validate stack size if (stack.size() < 2) { throw protocol_error("Invalid ptree structure"); } // Pop the nodes ptree_ptr p2 = stack.back(); stack.pop_back(); ptree_ptr p1 = stack.back(); stack.pop_back(); // Make sure they are not both proxies if (p1->is_proxy() && p2->is_proxy()) { throw protocol_error("Two proxy children in ptree"); } // Make sure they don't overflow sum if (p1->node_count() > k_max_ptree_nodes || p2->node_count() > k_max_ptree_nodes) { throw protocol_error("Node count overflow"); } uint8_t split_pos = type; // If they are both actual nodes, make sure split_pos matches + order is right if (!p1->is_proxy() && !p2->is_proxy()) { uint64_t validate_split = p1->prefix().first_diff(p2->prefix()); if (validate_split != split_pos) { throw protocol_error("Invalid node split position"); } if (p1->prefix() >= p2->prefix()) { throw protocol_error("Invalid node order"); } } else if (p1->is_proxy()) { // Check p2 is 1 bit at proper spot if (p2->prefix().get_bit(split_pos) != 1) { throw protocol_error("Invalid bit next to proxy"); } } else { // p2->is_proxy() if (p1->prefix().get_bit(split_pos) != 0) { throw protocol_error("Invalid bit next to proxy"); } } // Either way, make sure split position is smaller as we go up stack uint8_t s2 = split_stack.back(); split_stack.pop_back(); uint8_t s1 = split_stack.back(); split_stack.pop_back(); if (min(s1, s2) <= type) { throw protocol_error("Invalid split pos structure"); } // Make node + push ptree_ptr p = make_shared<ptree_branch>(split_pos, p1, p2); stack.push_back(p); split_stack.push_back(split_pos); } } // There should be zero or 1 entries on the stack if (stack.size() > 1) { throw protocol_error("Invalid stack at EOF of ptree"); } // If it's zero, it's an empty ptree! if (stack.size() == 0) { m_root = ptree_ptr(); } // If it's one entry, make sure it's not a proxy if (stack[0]->is_proxy()) { throw protocol_error("Pure proxy ptree is invalid"); } // Otherwise, we are good m_root = stack[0]; }
void client::recv_int_ok_reply_() { if (recv_int_reply_() != 1) throw protocol_error("expecting int reply of 1"); }
int main (int argc, char **argv) { gchar *confdir; gchar *host = g_strdup ("localhost"); gchar *port = g_strdup ("22"); gchar *sshkey = NULL; gchar *user = NULL; gchar *password = NULL; gchar *session = g_strdup ("thinnx"); gchar *type = g_strdup ("unix-gnome"); gchar *cookie = NULL; gboolean use_ssl = 0; gchar *link = g_strdup ("adsl"); gchar *kbdtype = g_strdup ("pc104/us"); gchar *geometry = g_strdup ("fullscreen"); gchar *screeninfo = NULL; gchar *session_id = NULL; gchar *session_display = NULL; gchar *pcookie = NULL; gchar **nxssh_argv = (gchar**) g_malloc (sizeof(gchar*) * 9); gchar *restore_id = NULL; pid_t pid; int parent_pipe[2]; /* For talking to the parent */ int child_pipe[2]; /* For talking to the child */ gint in = 0, out = 0; gtk_init (&argc, &argv); homedir = g_get_home_dir (); confdir = g_strdup_printf ("%s/.nx/", homedir); sshkey = g_strdup_printf ("%s/.ssh/id_dsa", homedir); { struct stat info; if (stat (confdir, &info) == -1) { if (mkdir (confdir, 0777) == -1) g_critical ("Could not create directory %s: %s\n", confdir, strerror (errno)); } } { #if GTK_MAJOR_VERSION == 2 GdkScreen *screen; screen = gdk_screen_get_default (); screeninfo = g_strdup_printf ("%dx%dx%d+render", gdk_screen_get_width (screen), gdk_screen_get_height (screen), gdk_visual_get_best_depth ()); #else screeninfo = g_strdup_printf ("%dx%dx%d+render", gdk_screen_width (), gdk_screen_height (), gdk_visual_get_best_depth ()); #endif } { /* get X authentication cookie information */ FILE *xauth_output; gchar xauth[256] = {0}; gchar *tmp = NULL; gchar **tmpv = NULL; gchar *display = NULL; /* avoid problems with "network" DISPLAY's */ display = g_strdup (getenv ("DISPLAY")); tmpv = g_strsplit (display, ":", 3); g_free (display); display = g_strdup_printf (":%s", tmpv[1]); g_strfreev (tmpv); /* get the authorization token */ tmp = g_strdup_printf (XAUTHBINDIR"/xauth list %s | " "grep 'MIT-MAGIC-COOKIE-1' | " "cut -d ' ' -f 5", display); if ((xauth_output = popen (tmp, "r")) == NULL) { g_critical ("Failed to obtain xauth key: %s", strerror(errno)); exit (1); } fread (xauth, sizeof(char), 256, xauth_output); xauth[strlen(xauth) - 1] = '\0'; pclose (xauth_output); g_free (tmp); if (!strcmp (xauth, "")) { message_dialog ("Não foi possível obter um cookie de autenticação\n" "do servidor X. Impossível continuar."); exit (1); } cookie = g_strdup (xauth); } { /* read configuration file */ FILE *fconf; gint fconf_fd; gchar **tmp, *key, *value; struct stat info; if (stat (CONFFILE, &info) == -1) { g_warning ("WARNING: Could not stat %s: %s.\n", CONFFILE, strerror (errno)); } fconf = fopen (CONFFILE, "r"); if (fconf == NULL) { g_critical ("Could not open %s: %s.\n", CONFFILE, strerror (errno)); } else { fconf_fd = fileno (fconf); while (!feof (fconf)) { buffer = read_line (fconf_fd); if (!buffer) break; /* remove comments */ tmp = g_strsplit (buffer, "#", 2); g_free (buffer); buffer = g_strdup (tmp[0]); g_strfreev (tmp); /* check if we still have a key/value pair */ tmp = g_strsplit (buffer, "=", 2); g_free (buffer); if (tmp[1] == NULL || tmp[0] == NULL) { g_strfreev (tmp); continue; } key = tmp[0]; value = tmp[1]; g_strstrip (key); g_strstrip (value); if (!strcmp ("host", key)) { g_free (host); host = g_strdup (value); } else if (!strcmp ("port", key)) { g_free (port); port = g_strdup (value); } else if (!strcmp ("sshkey", key)) { g_free (sshkey); sshkey = g_strdup (value); } else if (!strcmp ("session", key)) { g_free (session); session = g_strdup (value); } else if (!strcmp ("ssl", key)) { if (!strcmp (value, "yes")) use_ssl = 1; } else if (!strcmp ("type", key)) { g_free (type); type = g_strdup (value); } else if (!strcmp ("link", key)) { g_free (link); link = g_strdup (value); } else if (!strcmp ("kbdtype", key)) { g_free (kbdtype); kbdtype = g_strdup (value); } else if (!strcmp ("geometry", key)) { g_free (geometry); geometry = g_strdup (value); } else g_warning ("Unknown option in %s: %s=%s\n", CONFFILE, key, value); g_strfreev (tmp); } fclose (fconf); } } /* grab auth information from the user before anything else */ input_dialog (&user, &password); if (!strcmp (user, "root")) { message_dialog ("O usuário root não pode entrar por aqui!"); exit (1); } pipe (parent_pipe); pipe (child_pipe); pid = fork (); if (pid == -1) { g_critical ("Could not fork!\n"); exit (1); } else if (pid == 0) { close (child_pipe[1]); dup2 (child_pipe[0], STDIN_FILENO); dup2 (parent_pipe[1], STDOUT_FILENO); nxssh_argv[0] = g_strdup (BINDIR"/nxssh"); nxssh_argv[1] = g_strdup ("-nx"); nxssh_argv[2] = g_strdup_printf ("-p%s", port); nxssh_argv[3] = g_strdup ("-i"); nxssh_argv[4] = g_strdup (sshkey); nxssh_argv[5] = g_strdup_printf ("nx@%s", host); nxssh_argv[6] = g_strdup ("-2"); nxssh_argv[7] = g_strdup ("-S"); nxssh_argv[8] = NULL; execv (nxssh_argv[0], nxssh_argv); } else { close(parent_pipe[1]); out = parent_pipe[0]; in = child_pipe[1]; /* Handle initial hand-shaking */ { gboolean ssh_authed = FALSE; while (!ssh_authed) { buffer = read_code (out); if (!strcmp (buffer, "NX> 205")) { flush_buffer (buffer); drop_line (out); drop_line (out); drop_chars (out, 56); write_line (in, "yes"); drop_line (out); drop_line (out); /* buffer != NULL? but why?! */ buffer = NULL; } else if (!strcmp (buffer, "NX> 208")) { /* OK, authenticating... */ } else if (!strcmp (buffer, "NX> 203") || (!strcmp (buffer, "NX> 285")) || (!strcmp (buffer, "NX> 200")) || (!strcmp (buffer, "NX> 202"))) { /* ignored stderr */ } else if (!strncmp (buffer, "nxssh", 5)) { gchar *msg; flush_buffer (buffer); buffer = read_line (out); msg = get_info_after_colon (buffer); g_free (buffer); if (!strcmp (msg, "Name or service not known")) message_dialog ("Não foi possível resolver o nome do servidor."); else if (!strcmp (msg, "Connection refused")) message_dialog ("A conexão foi recusada!\n" "Verifique a porta."); else if (!strcmp (msg, "Connection timed out")) message_dialog ("Tempo limite da conexão expirou!\n" "Verifique servidor e porta."); flush_buffer (msg); fprintf (stderr, "\n"); exit (1); } else if (!strcmp (buffer, "NX> 204")) { message_dialog ("Falha na autenticação inicial!\n" "Confira a chave privada."); g_critical ("Failed to authenticate to SSH using the public key!\n"); exit (1); } else if (!strcmp (buffer, "HELLO N")) { /* OK, time to say HELLO! */ ssh_authed = TRUE; } else protocol_error ("problems waiting for HELLO"); flush_buffer (buffer); buffer = read_line (out); flush_buffer (buffer); } } /* Handle HELLO */ buffer = read_code (out); if (!strcmp (buffer, "NX> 105")) { flush_buffer (buffer); drop_chars (out, 1); write_line (in, "HELLO NXCLIENT - Version 1.4.0"); drop_line (out); } else protocol_error ("problems during HELLO"); /* Handle Login */ buffer = read_code (out); if (!strcmp (buffer, "NX> 134")) { flush_buffer (buffer); buffer = read_line (out); flush_buffer (buffer); } else protocol_error ("HELLO failed?"); buffer = read_code (out); if (!strcmp (buffer, "NX> 105")) { flush_buffer (buffer); drop_chars (out, 1); write_line (in, "login"); drop_line (out); } else protocol_error ("No login? How come!"); buffer = read_code (out); if (!strcmp (buffer, "NX> 101")) { flush_buffer (buffer); drop_chars (out, 7); write_line (in, user); drop_line (out); } else protocol_error ("who took my login prompt away?"); buffer = read_code (out); if (!strcmp (buffer, "NX> 102")) { flush_buffer (buffer); drop_chars (out, 11); write_line (in, password); drop_line (out); } else protocol_error ("where is my password prompt?"); buffer = read_code (out); if (!strcmp (buffer, "NX> 103")) { flush_buffer (buffer); drop_line (out); } else { flush_buffer (buffer); message_dialog ("Login ou senha incorretos!"); exit (1); } buffer = read_code (out); if (!strcmp (buffer, "NX> 105")) { gchar *m; flush_buffer (buffer); drop_chars (out, 1); m = g_strdup_printf ("list %s", user); write_line (in, m); g_free (m); drop_lines (out, 5); while (1) { buffer = read_code (out); if (!strcmp (buffer, "NX> 105")) { flush_buffer (buffer); drop_chars (out, 1); break; } flush_buffer (buffer); buffer = read_line (out); restore_id = get_restore_id (buffer); } } else protocol_error ("session startup, buddy, I don't want problems!"); { gchar *cmdline; if (!restore_id) cmdline = g_strdup_printf ("startsession --session=\"%s\" --type=\"%s\" --cache=\"8M\" --images=\"32M\" --cookie=\"%s\" --link=\"%s\" --kbtype=\"%s\" --nodelay=\"1\" --backingstore=\"never\" --geometry=\"%s\" --media=\"0\" --agent_server=\"\" --agent_user=\"\" --agent_password=\"\" --screeninfo=\"%s\" --encryption=\"%d\"", session, type, cookie, link, kbdtype, geometry, screeninfo, use_ssl); else cmdline = g_strdup_printf ("restoresession --session=\"%s\" --type=\"%s\" --cache=\"8M\" --images=\"32M\" --cookie=\"%s\" --link=\"%s\" --kbtype=\"%s\" --nodelay=\"1\" --backingstore=\"never\" --geometry=\"%s\" --media=\"0\" --agent_server=\"\" --agent_user=\"\" --agent_password=\"\" --screeninfo=\"%s\" --encryption=\"%d\" --id=\"%s\"", session, type, cookie, link, kbdtype, geometry, screeninfo, use_ssl, restore_id); write_line (in, cmdline); g_free (cmdline); cmdline = NULL; drop_lines (out, 4); } session_id = get_session_info (out, "NX> 700"); session_display = get_session_info (out, "NX> 705"); drop_line (out); /* 703 (session type) */ pcookie = get_session_info (out, "NX> 701"); drop_line (out); /* 702 proxy ip */ drop_line (out); /* 706 agent cookie */ drop_line (out); /* 704 session cache */ { gchar *tmp = get_session_info (out, "NX> 707"); /* 707 ssl tunneling */ use_ssl = atoi (tmp); g_free (tmp); } drop_line (out); /* 710 session status: running */ drop_line (out); /* 1002 commit */ drop_line (out); /* 1006 session status: running */ read_code (out); drop_chars (out, 1); /* now prepare to run nxproxy */ { FILE *options; gchar *dirname; gchar *fname; gchar *cmdline; dirname = g_strdup_printf ("%s/.nx/S-%s", homedir, session_id); fname = g_strdup_printf ("%s/options", dirname); g_print ("Dir: %s\nFname: %s\n", dirname, fname); if (mkdir (dirname, 0777) == -1) { /* BOMB or handle 'directory already exists' */ } g_free (dirname); if (use_ssl) buffer = g_strdup_printf ("cookie=%s,root=%s/.nx,session=%s,id=%s,listen=%d:%s", pcookie, homedir, session, session_id, 8008, session_display); else buffer = g_strdup_printf ("cookie=%s,root=%s/.nx,session=%s,id=%s,connect=%s:%s", pcookie, homedir, session, session_id, host, session_display); options = fopen (fname, "w"); fwrite (buffer, sizeof(char), strlen (buffer), options); fclose (options); g_free (buffer); cmdline = g_strdup_printf (BINDIR"/nxproxy -S options=%s:%s", fname, session_display); system (cmdline); g_free (cmdline); g_free (fname); } } write_line (in, "bye"); drop_line (out); if (use_ssl) write_line (in, "switch"); drop_line (out); drop_line (out); drop_line (out); return 0; }