GVfsFtpConnection * g_vfs_ftp_connection_new (GSocketConnectable *addr, GCancellable * cancellable, GError ** error) { GVfsFtpConnection *conn; g_return_val_if_fail (G_IS_SOCKET_CONNECTABLE (addr), NULL); conn = g_slice_new0 (GVfsFtpConnection); conn->client = g_socket_client_new (); conn->debug_id = g_atomic_int_add (&debug_id, 1); conn->commands = G_IO_STREAM (g_socket_client_connect (conn->client, addr, cancellable, error)); if (conn->commands == NULL) { g_object_unref (conn->client); g_slice_free (GVfsFtpConnection, conn); return NULL; } conn->connection = G_SOCKET_CONNECTION (conn->commands); enable_nodelay (conn->connection); enable_keepalive (conn->connection); create_input_stream (conn); /* The first thing that needs to happen is receiving the welcome message */ conn->waiting_for_reply = TRUE; return conn; }
/** * g_vfs_ftp_connection_accept_data_connection: * @conn: a listening connection * @cancellable: cancellable to interrupt wait * @error: %NULL or location to take a potential error * * Opens a data connection for @conn by accepting an incoming connection on the * address it is listening on via g_vfs_ftp_connection_listen_data_connection(), * which must have been called prior to this function. * If this function succeeds, a data connection will have been opened, and calls * to g_vfs_ftp_connection_get_data_stream() will work. * * Returns: %TRUE if a connection was successfully acquired **/ gboolean g_vfs_ftp_connection_accept_data_connection (GVfsFtpConnection *conn, GCancellable * cancellable, GError ** error) { GSocket *accepted; GCancellable *timer; gulong cancel_cb_id; GIOCondition condition; g_return_val_if_fail (conn != NULL, FALSE); g_return_val_if_fail (conn->data == NULL, FALSE); g_return_val_if_fail (G_IS_SOCKET (conn->listen_socket), FALSE); timer = g_cancellable_new (); cancel_cb_id = g_cancellable_connect (cancellable, G_CALLBACK (cancel_timer_cb), timer, NULL); g_object_ref (timer); g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, G_VFS_FTP_TIMEOUT_IN_SECONDS, cancel_cancellable, timer, g_object_unref); condition = g_socket_condition_wait (conn->listen_socket, G_IO_IN, timer, error); g_cancellable_disconnect (cancellable, cancel_cb_id); g_object_unref (timer); if ((condition & G_IO_IN) == 0) { if (g_cancellable_is_cancelled (timer) && !g_cancellable_is_cancelled (cancellable)) { g_clear_error (error); g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_HOST_NOT_FOUND, _("Failed to create active FTP connection. " "Maybe your router does not support this?")); } else if (error && *error == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_HOST_NOT_FOUND, _("Failed to create active FTP connection.")); } return FALSE; } accepted = g_socket_accept (conn->listen_socket, cancellable, error); if (accepted == NULL) return FALSE; conn->data = G_IO_STREAM (g_socket_connection_factory_create_connection (accepted)); g_object_unref (accepted); enable_nodelay (G_SOCKET_CONNECTION (conn->data)); return TRUE; }
/* * Accept a new Telnet connection. */ static void telnet_accept(void *vp) { ndesc_t *nd = vp; int addrlen, s; struct sockaddr_in addr; telnet_t *tp; void *ip; nd_enable(nd, ND_R); addrlen = sizeof (addr); s = accept(nd_fd(nd), (struct sockaddr *)&addr, &addrlen); if (s == -1) { switch (errno) { default: warning("telnet_accept: accept() errno = %d. ip: %s\n", errno, inet_ntoa(addr.sin_addr)); case EWOULDBLOCK: case EINTR: case EPROTO: return; } } enable_nbio(s); enable_oobinline(s); enable_nodelay(s); enable_lowdelay(s); enable_keepalive(s); set_rcvsize(s, TELNET_RCVBUF_SIZE); set_sndsize(s, TELNET_SNDBUF_SIZE); tp = telnet_alloc(); tp->t_nd = nd_attach(s, telnet_read, telnet_write, telnet_exception, NULL, telnet_shutdown, tp); ip = (void *)new_player(tp, &addr, addrlen); if (ip == NULL) { telnet_shutdown(tp->t_nd, tp); } else { telnet_attach(tp, ip); nd_enable(tp->t_nd, ND_R | ND_X); } }
gboolean g_vfs_ftp_connection_open_data_connection (GVfsFtpConnection *conn, GSocketAddress * addr, GCancellable * cancellable, GError ** error) { g_return_val_if_fail (conn != NULL, FALSE); g_return_val_if_fail (conn->data == NULL, FALSE); g_vfs_ftp_connection_stop_listening (conn); conn->data = G_IO_STREAM (g_socket_client_connect (conn->client, G_SOCKET_CONNECTABLE (addr), cancellable, error)); if (conn->data) enable_nodelay (G_SOCKET_CONNECTION (conn->data)); return conn->data != NULL; }
/* Look for needle, starting at (current, current_x). begin is the line * where we first started searching, at column begin_x. The return * value specifies whether we found anything. If we did, set needle_len * to the length of the string we found if it isn't NULL. */ bool findnextstr( #ifndef DISABLE_SPELLER bool whole_word_only, #endif const filestruct *begin, size_t begin_x, const char *needle, size_t *needle_len) { size_t found_len; /* The length of the match we find. */ size_t current_x_find = 0; /* The location in the current line of the match we find. */ ssize_t current_y_find = openfile->current_y; filestruct *fileptr = openfile->current; const char *rev_start = fileptr->data, *found = NULL; time_t lastkbcheck = time(NULL); /* rev_start might end up 1 character before the start or after the * end of the line. This won't be a problem because strstrwrapper() * will return immediately and say that no match was found, and * rev_start will be properly set when the search continues on the * previous or next line. */ rev_start += #ifndef NANO_TINY ISSET(BACKWARDS_SEARCH) ? ((openfile->current_x == 0) ? -1 : move_mbleft(fileptr->data, openfile->current_x)) : #endif move_mbright(fileptr->data, openfile->current_x); /* Look for needle in the current line we're searching. */ enable_nodelay(); while (TRUE) { if (time(NULL) - lastkbcheck > 1) { int input = parse_kbinput(edit); lastkbcheck = time(NULL); if (input && func_from_key(&input) == do_cancel) { statusbar(_("Cancelled")); return FALSE; } } found = strstrwrapper(fileptr->data, needle, rev_start); /* We've found a potential match. */ if (found != NULL) { #ifndef DISABLE_SPELLER bool found_whole = FALSE; /* Is this potential match a whole word? */ #endif /* Set found_len to the length of the potential match. */ found_len = #ifdef HAVE_REGEX_H ISSET(USE_REGEXP) ? regmatches[0].rm_eo - regmatches[0].rm_so : #endif strlen(needle); #ifndef DISABLE_SPELLER /* If we're searching for whole words, see if this potential * match is a whole word. */ if (whole_word_only) { char *word = mallocstrncpy(NULL, found, found_len + 1); word[found_len] = '\0'; found_whole = is_whole_word(found - fileptr->data, fileptr->data, word); free(word); } /* If we're searching for whole words and this potential * match isn't a whole word, continue searching. */ if (!whole_word_only || found_whole) #endif break; } if (search_last_line) { /* We've finished processing the file, so get out. */ not_found_msg(needle); disable_nodelay(); return FALSE; } /* Move to the previous or next line in the file. */ #ifndef NANO_TINY if (ISSET(BACKWARDS_SEARCH)) { fileptr = fileptr->prev; current_y_find--; } else { #endif fileptr = fileptr->next; current_y_find++; #ifndef NANO_TINY } #endif if (fileptr == NULL) { /* We've reached the start or end of the buffer, so wrap around. */ #ifndef NANO_TINY if (ISSET(BACKWARDS_SEARCH)) { fileptr = openfile->filebot; current_y_find = editwinrows - 1; } else { #endif fileptr = openfile->fileage; current_y_find = 0; #ifndef NANO_TINY } #endif statusbar(_("Search Wrapped")); } if (fileptr == begin) /* We've reached the original starting line. */ search_last_line = TRUE; rev_start = fileptr->data; #ifndef NANO_TINY if (ISSET(BACKWARDS_SEARCH)) rev_start += strlen(fileptr->data); #endif } /* We found an instance. */ current_x_find = found - fileptr->data; /* Ensure we haven't wrapped around again! */ if (search_last_line && #ifndef NANO_TINY ((!ISSET(BACKWARDS_SEARCH) && current_x_find > begin_x) || (ISSET(BACKWARDS_SEARCH) && current_x_find < begin_x)) #else current_x_find > begin_x #endif ) { not_found_msg(needle); disable_nodelay(); return FALSE; } disable_nodelay(); /* We've definitely found something. */ openfile->current = fileptr; openfile->current_x = current_x_find; openfile->placewewant = xplustabs(); openfile->current_y = current_y_find; /* needle_len holds the length of needle. */ if (needle_len != NULL) *needle_len = found_len; return TRUE; }