BOOL nego_tcp_connect(rdpNego* nego) { if (!nego->TcpConnected) { if (nego->GatewayEnabled) { if (nego->GatewayBypassLocal) { /* Attempt a direct connection first, and then fallback to using the gateway */ WLog_INFO(TAG, "Detecting if host can be reached locally. - This might take some time."); WLog_INFO(TAG, "To disable auto detection use /gateway-usage-method:direct"); transport_set_gateway_enabled(nego->transport, FALSE); nego->TcpConnected = transport_connect(nego->transport, nego->hostname, nego->port, 1); } if (!nego->TcpConnected) { transport_set_gateway_enabled(nego->transport, TRUE); nego->TcpConnected = transport_connect(nego->transport, nego->hostname, nego->port, 15); } } else { nego->TcpConnected = transport_connect(nego->transport, nego->hostname, nego->port, 15); } } return nego->TcpConnected; }
static GIOChannel *unix_connect(GObexTransportType transport) { GIOChannel *io; struct sockaddr_un addr = { AF_UNIX, "\0/gobex/server" }; int sk, err, sock_type; if (option_packet) sock_type = SOCK_SEQPACKET; else sock_type = SOCK_STREAM; sk = socket(PF_LOCAL, sock_type, 0); if (sk < 0) { err = errno; g_printerr("Can't create unix socket: %s (%d)\n", strerror(err), err); return NULL; } if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { err = errno; g_printerr("connect: %s (%d)\n", strerror(err), err); return NULL; } io = g_io_channel_unix_new(sk); g_print("Unix socket created: %d\n", sk); transport_connect(io, transport); return io; }
BOOL nego_tcp_connect(rdpNego* nego) { if (!nego->tcp_connected) nego->tcp_connected = transport_connect(nego->transport, nego->hostname, nego->port); return nego->tcp_connected; }
static void conn_callback(GIOChannel *io, GError *err, gpointer user_data) { GObexTransportType transport = GPOINTER_TO_UINT(user_data); if (err != NULL) { g_printerr("%s\n", err->message); return; } g_print("Bluetooth socket connected\n"); transport_connect(io, transport); }
static int run_remote_archiver(int argc, const char **argv, const char *remote, const char *exec, const char *name_hint) { char buf[LARGE_PACKET_MAX]; int fd[2], i, len, rv; struct transport *transport; struct remote *_remote; _remote = remote_get(remote); if (!_remote->url[0]) die(_("git archive: Remote with no URL")); transport = transport_get(_remote, _remote->url[0]); transport_connect(transport, "git-upload-archive", exec, fd); /* * Inject a fake --format field at the beginning of the * arguments, with the format inferred from our output * filename. This way explicit --format options can override * it. */ if (name_hint) { const char *format = archive_format_from_filename(name_hint); if (format) packet_write(fd[1], "argument --format=%s\n", format); } for (i = 1; i < argc; i++) packet_write(fd[1], "argument %s\n", argv[i]); packet_flush(fd[1]); len = packet_read_line(fd[0], buf, sizeof(buf)); if (!len) die(_("git archive: expected ACK/NAK, got EOF")); if (buf[len-1] == '\n') buf[--len] = 0; if (strcmp(buf, "ACK")) { if (len > 5 && !prefixcmp(buf, "NACK ")) die(_("git archive: NACK %s"), buf + 5); die(_("git archive: protocol error")); } len = packet_read_line(fd[0], buf, sizeof(buf)); if (len) die(_("git archive: expected a flush")); /* Now, start reading from fd[0] and spit it out to stdout */ rv = recv_sideband("archive", fd[0], 1); rv |= transport_disconnect(transport); return !!rv; }
boolean nego_tcp_connect(rdpNego* nego) { if (nego->tcp_connected == 0) { if (transport_connect(nego->transport, nego->hostname, nego->port) == false) { nego->tcp_connected = 0; return false; } else { nego->tcp_connected = 1; return true; } } return true; }
static int session_connect(struct bluetooth_session *session) { int err; if (session->port > 0) { session->io = transport_connect(&session->src, &session->dst, session->port, transport_callback, session); err = (session->io == NULL) ? -EINVAL : 0; } else { session->sdp = service_connect(&session->src, &session->dst, service_callback, session); err = (session->sdp == NULL) ? -ENOMEM : 0; } return err; }
static void instance_state_completion(char *state, char *address, void *data) { struct assembly *assembly = (struct assembly *)data; if (strcmp(state, "ACTIVE") == 0) { assembly->address = strdup(address); qb_util_stopwatch_stop(assembly->sw_instance_create); qb_log(LOG_INFO, "Instance '%s' with address '%s' changed to RUNNING in (%lld ms).", assembly->name, assembly->address, qb_util_stopwatch_us_elapsed_get(assembly->sw_instance_create) / 1000); qb_util_stopwatch_start(assembly->sw_instance_connected); transport_connect(assembly); } else { recover_state_set(&assembly->recover, RECOVER_STATE_UNKNOWN); qb_loop_timer_add(NULL, QB_LOOP_LOW, PENDING_TIMEOUT * QB_TIME_NS_IN_MSEC, assembly, my_instance_state_get, NULL); } }
static int run_remote_archiver(int argc, const char **argv, const char *remote, const char *exec) { char buf[LARGE_PACKET_MAX]; int fd[2], i, len, rv; struct transport *transport; struct remote *_remote; _remote = remote_get(remote); if (!_remote->url[0]) die(_("git archive: Remote with no URL")); transport = transport_get(_remote, _remote->url[0]); transport_connect(transport, "git-upload-archive", exec, fd); for (i = 1; i < argc; i++) packet_write(fd[1], "argument %s\n", argv[i]); packet_flush(fd[1]); len = packet_read_line(fd[0], buf, sizeof(buf)); if (!len) die(_("git archive: expected ACK/NAK, got EOF")); if (buf[len-1] == '\n') buf[--len] = 0; if (strcmp(buf, "ACK")) { if (len > 5 && !prefixcmp(buf, "NACK ")) die(_("git archive: NACK %s"), buf + 5); die(_("git archive: protocol error")); } len = packet_read_line(fd[0], buf, sizeof(buf)); if (len) die(_("git archive: expected a flush")); /* Now, start reading from fd[0] and spit it out to stdout */ rv = recv_sideband("archive", fd[0], 1); rv |= transport_disconnect(transport); return !!rv; }
static void search_callback(uint8_t type, uint16_t status, uint8_t *rsp, size_t size, void *user_data) { struct bluetooth_session *session = user_data; unsigned int scanned, bytesleft = size; int seqlen = 0; uint8_t dataType; uint16_t port = 0; GError *gerr = NULL; if (status || type != SDP_SVC_SEARCH_ATTR_RSP) goto failed; scanned = sdp_extract_seqtype(rsp, bytesleft, &dataType, &seqlen); if (!scanned || !seqlen) goto failed; rsp += scanned; bytesleft -= scanned; do { sdp_record_t *rec; sdp_list_t *protos; sdp_data_t *data; int recsize, ch = -1; recsize = 0; rec = sdp_extract_pdu(rsp, bytesleft, &recsize); if (!rec) break; if (!recsize) { sdp_record_free(rec); break; } if (!sdp_get_access_protos(rec, &protos)) { ch = sdp_get_proto_port(protos, RFCOMM_UUID); sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL); sdp_list_free(protos, NULL); protos = NULL; } data = sdp_data_get(rec, 0x0200); /* PSM must be odd and lsb of upper byte must be 0 */ if (data != NULL && (data->val.uint16 & 0x0101) == 0x0001) ch = data->val.uint16; sdp_record_free(rec); if (ch > 0) { port = ch; break; } scanned += recsize; rsp += recsize; bytesleft -= recsize; } while (scanned < size && bytesleft > 0); if (port == 0) goto failed; session->port = port; g_io_channel_set_close_on_unref(session->io, FALSE); g_io_channel_unref(session->io); session->io = transport_connect(&session->src, &session->dst, port, transport_callback, session); if (session->io != NULL) { sdp_close(session->sdp); session->sdp = NULL; return; } failed: if (session->io != NULL) { g_io_channel_shutdown(session->io, TRUE, NULL); g_io_channel_unref(session->io); session->io = NULL; } g_set_error(&gerr, OBC_BT_ERROR, -EIO, "Unable to find service record"); if (session->func) session->func(session->io, gerr, session->user_data); g_clear_error(&gerr); session_destroy(session); }