void func_reassign_connection(void) { cData * args; Conn * c; Obj * obj; /* Accept a objnum. */ if (!func_init_1(&args, OBJNUM)) return; c = find_connection(cur_frame->object); if (c) { obj = cache_retrieve(args[0].u.objnum); if (!obj) THROW((objnf_id, "Object #%l does not exist.", args[0].u.objnum)) else if (find_connection(obj)) { cthrow(perm_id, "Object %O already has a connection.", obj->objnum); cache_discard(obj); return; } c->objnum = obj->objnum; cache_discard(obj); cur_frame->object->conn = NULL; pop(1); push_int(1); } else {
static void CheckIsConnected (const NODE * node1, const NODE * node2) { int n1_to_n2; int n2_to_n1; #ifdef NDEBUG return; #endif n1_to_n2 = find_connection (node1, node2); n2_to_n1 = find_connection (node2, node1); assert (n1_to_n2 >= 0); assert (n2_to_n1 >= 0); assert (DBL_EQUALS (node1->blength[n1_to_n2], node2->blength[n2_to_n1])); }
uint32_t remove_connection(iscsid_remove_connection_req_t * req) { iscsi_remove_parameters_t removep; session_t *sess; connection_t *conn; int ret; LOCK_SESSIONS; sess = find_session(&req->session_id); if (sess == NULL) { UNLOCK_SESSIONS; return ISCSID_STATUS_INVALID_SESSION_ID; } conn = find_connection(sess, &req->connection_id); if (conn == NULL) { UNLOCK_SESSIONS; return ISCSID_STATUS_INVALID_CONNECTION_ID; } removep.session_id = sess->entry.sid.id; removep.connection_id = conn->entry.sid.id; UNLOCK_SESSIONS; ret = ioctl(driver, ISCSI_REMOVE_CONNECTION, &removep); DEB(9, ("Remove Connection returns %d, status=%d\n", ret, removep.status)); return removep.status; }
int input_device_unregister(const char *path, const char *uuid) { struct input_device *idev; struct input_conn *iconn; idev = find_device_by_path(devices, path); if (idev == NULL) return -EINVAL; iconn = find_connection(idev->connections, uuid); if (iconn == NULL) return -EINVAL; if (iconn->pending_connect) { /* Pending connection running */ return -EBUSY; } idev->connections = g_slist_remove(idev->connections, iconn); input_conn_free(iconn); if (idev->connections) return 0; g_dbus_unregister_interface(idev->conn, path, INPUT_DEVICE_INTERFACE); return 0; }
int input_device_close_channels(const bdaddr_t *src, const bdaddr_t *dst) { struct input_device *idev = find_device(src, dst); struct input_conn *iconn; char sstr[18], dstr[18]; ba2str(src, sstr); ba2str(dst, dstr); DBG("src %s, dst %s", sstr, dstr); DBG("idev %p", idev); if (!idev) return -ENOENT; iconn = find_connection(idev->connections, HID_UUID); if (!iconn) return -ENOENT; if (iconn->intr_io) g_io_channel_shutdown(iconn->intr_io, TRUE, NULL); if (iconn->ctrl_io) g_io_channel_shutdown(iconn->ctrl_io, TRUE, NULL); return 0; }
/* * Input Device methods */ static DBusMessage *input_device_connect(DBusConnection *conn, DBusMessage *msg, void *data) { struct input_device *idev = data; struct input_conn *iconn; DBusMessage *reply; GError *err = NULL; DBG("idev %p", idev); iconn = find_connection(idev->connections, HID_UUID); if (!iconn) return btd_error_not_supported(msg); if (iconn->pending_connect) return btd_error_in_progress(msg); if (is_connected(iconn)) return btd_error_already_connected(msg); iconn->pending_connect = dbus_message_ref(msg); dev_connect(idev, iconn, &err); if (err == NULL) return NULL; error("%s", err->message); dbus_message_unref(iconn->pending_connect); iconn->pending_connect = NULL; reply = btd_error_failed(msg, err->message); g_error_free(err); return reply; }
int input_device_set_channel(const bdaddr_t *src, const bdaddr_t *dst, int psm, GIOChannel *io) { struct input_device *idev = find_device(src, dst); struct input_conn *iconn; if (!idev) return -ENOENT; iconn = find_connection(idev->connections, "hid"); if (!iconn) return -ENOENT; switch (psm) { case L2CAP_PSM_HIDP_CTRL: if (iconn->ctrl_io) return -EALREADY; iconn->ctrl_io = g_io_channel_ref(io); break; case L2CAP_PSM_HIDP_INTR: if (iconn->intr_io) return -EALREADY; iconn->intr_io = g_io_channel_ref(io); break; } if (iconn->intr_io && iconn->ctrl_io) input_device_connadd(idev, iconn); return 0; }
int connection_register(struct btd_device *device, const char *path, bdaddr_t *src, bdaddr_t *dst, uint16_t id) { struct network_peer *peer; struct network_conn *nc; if (!path) return -EINVAL; peer = find_peer(peers, path); if (!peer) { peer = create_peer(device, path, src, dst); if (!peer) return -1; peers = g_slist_append(peers, peer); } nc = find_connection(peer->connections, id); if (nc) return 0; nc = g_new0(struct network_conn, 1); nc->id = id; memset(nc->dev, 0, sizeof(nc->dev)); strcpy(nc->dev, "bnep%d"); nc->state = DISCONNECTED; nc->peer = peer; peer->connections = g_slist_append(peer->connections, nc); return 0; }
void reap_children() { int status; int pid; int id; while ((pid = waitpid(-1, &status, WNOHANG)) > 0) { id = find_connection(pid); if (id < 0) continue; release_connection(id); } child_exited = 0; }
void ApplicationManager::connection_close(connection_info_t cinfo) { std::lock_guard<std::mutex> lck(this->lock); connection_info_t cinfo_orig = find_connection(cinfo->get_surface_id(), cinfo->get_security_token()); if (cinfo_orig == NULL) { mLOG_INFO("Cannot close specified connection (%S:%S)", cinfo->get_surface_id(), cinfo->get_security_token()); return false; } connections.remove(cinfo_orig); return true; }
static DBusMessage *input_device_connect(DBusConnection *conn, DBusMessage *msg, void *data) { struct input_device *idev = data; struct input_conn *iconn; struct fake_input *fake; DBusMessage *reply; GError *err = NULL; iconn = find_connection(idev->connections, "HID"); if (!iconn) return not_supported(msg); if (iconn->pending_connect) return in_progress(msg); if (is_connected(iconn)) return already_connected(msg); iconn->pending_connect = dbus_message_ref(msg); fake = iconn->fake; if (fake) { /* Fake input device */ if (fake->connect(iconn, &err)) fake->flags |= FI_FLAG_CONNECTED; } else { /* HID devices */ GIOChannel *io; io = bt_io_connect(BT_IO_L2CAP, control_connect_cb, iconn, NULL, &err, BT_IO_OPT_SOURCE_BDADDR, &idev->src, BT_IO_OPT_DEST_BDADDR, &idev->dst, BT_IO_OPT_PSM, L2CAP_PSM_HIDP_CTRL, BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW, BT_IO_OPT_INVALID); iconn->ctrl_io = io; } if (err == NULL) return NULL; error("%s", err->message); dbus_message_unref(iconn->pending_connect); iconn->pending_connect = NULL; reply = connection_attempt_failed(msg, err->message); g_error_free(err); return reply; }
/* Connect and initiate BNEP session */ static DBusMessage *connection_connect(DBusConnection *conn, DBusMessage *msg, void *data) { struct network_peer *peer = data; struct network_conn *nc; const char *svc; uint16_t id; GError *err = NULL; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &svc, DBUS_TYPE_INVALID) == FALSE) return NULL; id = bnep_service_id(svc); nc = find_connection(peer->connections, id); if (!nc) return btd_error_not_supported(msg); if (nc->state != DISCONNECTED) return btd_error_already_connected(msg); nc->io = bt_io_connect(BT_IO_L2CAP, connect_cb, nc, NULL, &err, BT_IO_OPT_SOURCE_BDADDR, &peer->src, BT_IO_OPT_DEST_BDADDR, &peer->dst, BT_IO_OPT_PSM, BNEP_PSM, BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, BT_IO_OPT_OMTU, BNEP_MTU, BT_IO_OPT_IMTU, BNEP_MTU, BT_IO_OPT_INVALID); if (!nc->io) { DBusMessage *reply; error("%s", err->message); reply = btd_error_failed(msg, err->message); g_error_free(err); return reply; } nc->state = CONNECTING; nc->msg = dbus_message_ref(msg); nc->watch = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), connection_destroy, nc, NULL); return NULL; }
static void connections_read (NMSettingsInterface *settings, gpointer user_data) { GSList *connections; NMConnection *connection; NMDevice *dev; struct start_network_data *data = (struct start_network_data *)user_data; static int tries = 0; if(!NM_IS_REMOTE_SETTINGS_SYSTEM(settings)) { network_status (data->client, "Not a settings_system object! Huh?\n"); g_main_loop_quit (loop); return; } connections = nm_settings_interface_list_connections (settings); connection = find_connection(connections, data->uuid); if (!connection) { if (tries++ >= 2) { network_status (data->client, "Unable to find connection from " NETWORK_CONFIG " in system configs file"); g_main_loop_quit(loop); return; } return; } dev = get_device_for_connection (data->client, connection); if (!dev) { network_status (data->client, "Unable to find correct device for connection"); g_main_loop_quit(loop); return; } data->should_quit = FALSE; nm_client_activate_connection (data->client, NM_DBUS_SERVICE_SYSTEM_SETTINGS, nm_connection_get_path (connection),//con_path, dev,//device, NULL,//spec_object, activate_connection_cb, data); return; }
int add_lengths_to_tree (TREE * tree, double *lengths) { int a, b; CheckIsTree (tree); assert (NULL != lengths); for (a = 0; a < tree->n_br; a++) { (tree->branches[a])->blength[0] = lengths[a]; b = find_connection (CHILD (tree->branches[a], 0), tree->branches[a]); CHILD (tree->branches[a], 0)->blength[b] = lengths[a]; } CheckIsTree (tree); return 0; }
void ControllerServer::handle_http_post( const HttpServer::Request & request , HttpServer::Response & response ) { PostMap::iterator it = post_map.find( request.get_path() ); if ( it == post_map.end() ) { return; } ConnectionInfo * info = find_connection( it->second.connection ); if ( ! info ) { return; } const HttpServer::Request::Body & body( request.get_body() ); if ( ! body.get_data() || ! body.get_length() ) { response.set_status( HttpServer::HTTP_STATUS_BAD_REQUEST ); return; } String ct( request.get_content_type() ); const char * content_type = ct.empty() ? 0 : ct.c_str(); switch ( it->second.type ) { case PostInfo::AUDIO: tp_controller_submit_audio_clip( info->controller , body.get_data() , body.get_length() , content_type ); break; case PostInfo::IMAGE: tp_controller_submit_image( info->controller , body.get_data() , body.get_length() , content_type ); break; } response.set_status( HttpServer::HTTP_STATUS_OK ); }
int input_device_close_channels(const bdaddr_t *src, const bdaddr_t *dst) { struct input_device *idev = find_device(src, dst); struct input_conn *iconn; if (!idev) return -ENOENT; iconn = find_connection(idev->connections, "hid"); if (!iconn) return -ENOENT; if (iconn->intr_io) g_io_channel_shutdown(iconn->intr_io, TRUE, NULL); if (iconn->ctrl_io) g_io_channel_shutdown(iconn->ctrl_io, TRUE, NULL); return 0; }
void connection_unregister(const char *path, uint16_t id) { struct network_peer *peer; struct network_conn *nc; peer = find_peer(peers, path); if (!peer) return; nc = find_connection(peer->connections, id); if (!nc) return; peer->connections = g_slist_remove(peer->connections, nc); connection_free(nc); if (peer->connections) return; g_dbus_unregister_interface(connection, path, NETWORK_PEER_INTERFACE); }
static gboolean input_device_auto_reconnect(gpointer user_data) { struct input_device *idev = user_data; struct input_conn *iconn; GError *err = NULL; DBG("idev %p", idev); DBG("path=%s, attempt=%d", idev->path, idev->reconnect_attempt); /* Stop the recurrent reconnection attempts if the device is reconnected * or is marked for removal. */ if (device_is_temporary(idev->device) || device_is_connected(idev->device)) return FALSE; /* Only attempt an auto-reconnect for at most 3 minutes (6 * 30s). */ if (idev->reconnect_attempt >= 6) return FALSE; iconn = find_connection(idev->connections, HID_UUID); if (iconn == NULL) return FALSE; if (iconn->ctrl_io) return FALSE; if (is_connected(iconn)) return FALSE; idev->reconnect_attempt++; dev_connect(idev, iconn, &err); if (err != NULL) { error("%s", err->message); g_error_free(err); return FALSE; } return TRUE; }
int input_device_set_channel(const bdaddr_t *src, const bdaddr_t *dst, int psm, GIOChannel *io) { struct input_device *idev = find_device(src, dst); struct input_conn *iconn; char sstr[18], dstr[18]; ba2str(src, sstr); ba2str(dst, dstr); DBG("src %s, dst %s", sstr, dstr); DBG("idev %p", idev); if (!idev) return -ENOENT; iconn = find_connection(idev->connections, HID_UUID); if (!iconn) return -ENOENT; switch (psm) { case L2CAP_PSM_HIDP_CTRL: if (iconn->ctrl_io) return -EALREADY; iconn->ctrl_io = g_io_channel_ref(io); break; case L2CAP_PSM_HIDP_INTR: if (iconn->intr_io) return -EALREADY; iconn->intr_io = g_io_channel_ref(io); break; } if (iconn->intr_io && iconn->ctrl_io) input_device_connadd(idev, iconn); return 0; }
void ControllerServer::connection_closed( gpointer connection ) { ConnectionInfo * info = find_connection( connection ); gpointer aui_connection = NULL; if ( info && info->controller ) { tp_context_remove_controller( context, info->controller ); aui_connection = info->aui_connection; } drop_resource_group( connection , String() ); drop_post_endpoint( connection ); connections.erase( connection ); if ( aui_connection ) { server->close_connection( aui_connection ); } tplog( "CONNECTION CLOSED %p", connection ); }
DWORD linux_proc_fill_program_name(struct connection_table * table_connection) { char buffer[60]; struct dirent *procent, *fdent; DIR * procfd, * pidfd; struct stat stat_buf; struct connection_entry * connection; procfd = opendir("/proc"); if (procfd == NULL) return -1; while ((procent = readdir(procfd)) != NULL) { // not a pid directory if (!isdigit(*(procent->d_name))) continue; snprintf(buffer, sizeof(buffer), "/proc/%s/fd/", procent->d_name); if ((pidfd = opendir(buffer)) == NULL) continue; while((fdent = readdir(pidfd)) != NULL) { snprintf(buffer, sizeof(buffer), "/proc/%s/fd/%s", procent->d_name, fdent->d_name); if (stat(buffer, &stat_buf) < 0) continue; if (!S_ISSOCK(stat_buf.st_mode)) continue; // ok, FD is a socket, search if we have it in our list if ((connection = find_connection(table_connection, stat_buf.st_ino)) != NULL) linux_proc_get_program_name(connection, procent->d_name); } closedir(pidfd); } closedir(procfd); return 0; }
int ldap_send_server_request( LDAP *ld, BerElement *ber, ber_int_t msgid, LDAPRequest *parentreq, LDAPURLDesc **srvlist, LDAPConn *lc, LDAPreqinfo *bind, int m_noconn, int m_res ) { LDAPRequest *lr; int incparent, rc; LDAP_ASSERT_MUTEX_OWNER( &ld->ld_req_mutex ); Debug( LDAP_DEBUG_TRACE, "ldap_send_server_request\n", 0, 0, 0 ); incparent = 0; ld->ld_errno = LDAP_SUCCESS; /* optimistic */ LDAP_CONN_LOCK_IF(m_noconn); if ( lc == NULL ) { if ( srvlist == NULL ) { lc = ld->ld_defconn; } else { lc = find_connection( ld, *srvlist, 1 ); if ( lc == NULL ) { if ( (bind != NULL) && (parentreq != NULL) ) { /* Remember the bind in the parent */ incparent = 1; ++parentreq->lr_outrefcnt; } lc = ldap_new_connection( ld, srvlist, 0, 1, bind, 1, m_res ); } } } /* async connect... */ if ( lc != NULL && lc->lconn_status == LDAP_CONNST_CONNECTING ) { ber_socket_t sd = AC_SOCKET_ERROR; struct timeval tv = { 0 }; ber_sockbuf_ctrl( lc->lconn_sb, LBER_SB_OPT_GET_FD, &sd ); /* poll ... */ switch ( ldap_int_poll( ld, sd, &tv, 1 ) ) { case 0: /* go on! */ lc->lconn_status = LDAP_CONNST_CONNECTED; break; case -2: /* async only occurs if a network timeout is set */ /* honor network timeout */ LDAP_MUTEX_LOCK( &ld->ld_options.ldo_mutex ); if ( time( NULL ) - lc->lconn_created <= ld->ld_options.ldo_tm_net.tv_sec ) { /* caller will have to call again */ ld->ld_errno = LDAP_X_CONNECTING; } LDAP_MUTEX_UNLOCK( &ld->ld_options.ldo_mutex ); /* fallthru */ default: /* error */ break; } } if ( lc == NULL || lc->lconn_status != LDAP_CONNST_CONNECTED ) { if ( ld->ld_errno == LDAP_SUCCESS ) { ld->ld_errno = LDAP_SERVER_DOWN; } ber_free( ber, 1 ); if ( incparent ) { /* Forget about the bind */ --parentreq->lr_outrefcnt; } LDAP_CONN_UNLOCK_IF(m_noconn); return( -1 ); } use_connection( ld, lc ); #ifdef LDAP_CONNECTIONLESS if ( LDAP_IS_UDP( ld )) { BerElement tmpber = *ber; ber_rewind( &tmpber ); LDAP_MUTEX_LOCK( &ld->ld_options.ldo_mutex ); rc = ber_write( &tmpber, ld->ld_options.ldo_peer, sizeof( struct sockaddr_storage ), 0 ); LDAP_MUTEX_UNLOCK( &ld->ld_options.ldo_mutex ); if ( rc == -1 ) { ld->ld_errno = LDAP_ENCODING_ERROR; LDAP_CONN_UNLOCK_IF(m_noconn); return rc; } } #endif /* If we still have an incomplete write, try to finish it before * dealing with the new request. If we don't finish here, return * LDAP_BUSY and let the caller retry later. We only allow a single * request to be in WRITING state. */ rc = 0; if ( ld->ld_requests && ld->ld_requests->lr_status == LDAP_REQST_WRITING && ldap_int_flush_request( ld, ld->ld_requests ) < 0 ) { rc = -1; } if ( rc ) { LDAP_CONN_UNLOCK_IF(m_noconn); return rc; } lr = (LDAPRequest *)LDAP_CALLOC( 1, sizeof( LDAPRequest ) ); if ( lr == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; ldap_free_connection( ld, lc, 0, 0 ); ber_free( ber, 1 ); if ( incparent ) { /* Forget about the bind */ --parentreq->lr_outrefcnt; } LDAP_CONN_UNLOCK_IF(m_noconn); return( -1 ); } lr->lr_msgid = msgid; lr->lr_status = LDAP_REQST_INPROGRESS; lr->lr_res_errno = LDAP_SUCCESS; /* optimistic */ lr->lr_ber = ber; lr->lr_conn = lc; if ( parentreq != NULL ) { /* sub-request */ if ( !incparent ) { /* Increment if we didn't do it before the bind */ ++parentreq->lr_outrefcnt; } lr->lr_origid = parentreq->lr_origid; lr->lr_parentcnt = ++parentreq->lr_parentcnt; lr->lr_parent = parentreq; lr->lr_refnext = parentreq->lr_child; parentreq->lr_child = lr; } else { /* original request */ lr->lr_origid = lr->lr_msgid; } /* Extract requestDN for future reference */ #ifdef LDAP_CONNECTIONLESS if ( !LDAP_IS_UDP(ld) ) #endif { BerElement tmpber = *ber; ber_int_t bint; ber_tag_t tag, rtag; ber_reset( &tmpber, 1 ); rtag = ber_scanf( &tmpber, "{it", /*}*/ &bint, &tag ); switch ( tag ) { case LDAP_REQ_BIND: rtag = ber_scanf( &tmpber, "{i" /*}*/, &bint ); break; case LDAP_REQ_DELETE: break; default: rtag = ber_scanf( &tmpber, "{" /*}*/ ); case LDAP_REQ_ABANDON: break; } if ( tag != LDAP_REQ_ABANDON ) { ber_skip_tag( &tmpber, &lr->lr_dn.bv_len ); lr->lr_dn.bv_val = tmpber.ber_ptr; } } lr->lr_prev = NULL; lr->lr_next = ld->ld_requests; if ( lr->lr_next != NULL ) { lr->lr_next->lr_prev = lr; } ld->ld_requests = lr; ld->ld_errno = LDAP_SUCCESS; if ( ldap_int_flush_request( ld, lr ) == -1 ) { msgid = -1; } LDAP_CONN_UNLOCK_IF(m_noconn); return( msgid ); }
/* * XXX merging of errors in this routine needs to be improved * Protected by res_mutex, conn_mutex and req_mutex (try_read1msg) */ int ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int sref, int *hadrefp ) { int rc, count, id; unsigned len; char *p, *ref, *unfollowed; LDAPRequest *origreq; LDAPURLDesc *srv; BerElement *ber; LDAPreqinfo rinfo; LDAPConn *lc; LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex ); LDAP_ASSERT_MUTEX_OWNER( &ld->ld_conn_mutex ); LDAP_ASSERT_MUTEX_OWNER( &ld->ld_req_mutex ); Debug( LDAP_DEBUG_TRACE, "ldap_chase_referrals\n", 0, 0, 0 ); ld->ld_errno = LDAP_SUCCESS; /* optimistic */ *hadrefp = 0; if ( *errstrp == NULL ) { return( 0 ); } len = strlen( *errstrp ); for ( p = *errstrp; len >= LDAP_REF_STR_LEN; ++p, --len ) { if ( strncasecmp( p, LDAP_REF_STR, LDAP_REF_STR_LEN ) == 0 ) { *p = '\0'; p += LDAP_REF_STR_LEN; break; } } if ( len < LDAP_REF_STR_LEN ) { return( 0 ); } if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) { Debug( LDAP_DEBUG_ANY, "more than %d referral hops (dropping)\n", ld->ld_refhoplimit, 0, 0 ); /* XXX report as error in ld->ld_errno? */ return( 0 ); } /* find original request */ for ( origreq = lr; origreq->lr_parent != NULL; origreq = origreq->lr_parent ) { /* empty */; } unfollowed = NULL; rc = count = 0; /* parse out & follow referrals */ for ( ref = p; rc == 0 && ref != NULL; ref = p ) { p = strchr( ref, '\n' ); if ( p != NULL ) { *p++ = '\0'; } rc = ldap_url_parse_ext( ref, &srv, LDAP_PVT_URL_PARSE_NOEMPTY_DN ); if ( rc != LDAP_URL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "ignoring %s referral <%s>\n", ref, rc == LDAP_URL_ERR_BADSCHEME ? "unknown" : "incorrect", 0 ); rc = ldap_append_referral( ld, &unfollowed, ref ); *hadrefp = 1; continue; } Debug( LDAP_DEBUG_TRACE, "chasing LDAP referral: <%s>\n", ref, 0, 0 ); *hadrefp = 1; /* See if we've already been here */ if (( lc = find_connection( ld, srv, 1 )) != NULL ) { LDAPRequest *lp; int looped = 0; ber_len_t len = srv->lud_dn ? strlen( srv->lud_dn ) : 0; for ( lp = lr; lp; lp = lp->lr_parent ) { if ( lp->lr_conn == lc && len == lp->lr_dn.bv_len ) { if ( len && strncmp( srv->lud_dn, lp->lr_dn.bv_val, len ) ) continue; looped = 1; break; } } if ( looped ) { ldap_free_urllist( srv ); ld->ld_errno = LDAP_CLIENT_LOOP; rc = -1; continue; } } LDAP_NEXT_MSGID( ld, id ); ber = re_encode_request( ld, origreq->lr_ber, id, sref, srv, &rinfo.ri_request ); if ( ber == NULL ) { return -1 ; } /* copy the complete referral for rebind process */ rinfo.ri_url = LDAP_STRDUP( ref ); rinfo.ri_msgid = origreq->lr_origid; rc = ldap_send_server_request( ld, ber, id, lr, &srv, NULL, &rinfo, 0, 1 ); LDAP_FREE( rinfo.ri_url ); if( rc >= 0 ) { ++count; } else { Debug( LDAP_DEBUG_ANY, "Unable to chase referral \"%s\" (%d: %s)\n", ref, ld->ld_errno, ldap_err2string( ld->ld_errno ) ); rc = ldap_append_referral( ld, &unfollowed, ref ); } ldap_free_urllist(srv); } LDAP_FREE( *errstrp ); *errstrp = unfollowed; return(( rc == 0 ) ? count : rc ); }
/* * Chase v3 referrals * * Parameters: * (IN) ld = LDAP connection handle * (IN) lr = LDAP Request structure * (IN) refs = array of pointers to referral strings that we will chase * The array will be free'd by this function when no longer needed * (IN) sref != 0 if following search reference * (OUT) errstrp = Place to return a string of referrals which could not be followed * (OUT) hadrefp = 1 if sucessfully followed referral * * Return value - number of referrals followed * * Protected by res_mutex, conn_mutex and req_mutex (try_read1msg) */ int ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr, char **refs, int sref, char **errstrp, int *hadrefp ) { char *unfollowed; int unfollowedcnt = 0; LDAPRequest *origreq; LDAPURLDesc *srv = NULL; BerElement *ber; char **refarray = NULL; LDAPConn *lc; int rc, count, i, j, id; LDAPreqinfo rinfo; LDAP_NEXTREF_PROC *nextref_proc = ld->ld_nextref_proc ? ld->ld_nextref_proc : ldap_int_nextref; LDAP_ASSERT_MUTEX_OWNER( &ld->ld_res_mutex ); LDAP_ASSERT_MUTEX_OWNER( &ld->ld_conn_mutex ); LDAP_ASSERT_MUTEX_OWNER( &ld->ld_req_mutex ); Debug( LDAP_DEBUG_TRACE, "ldap_chase_v3referrals\n", 0, 0, 0 ); ld->ld_errno = LDAP_SUCCESS; /* optimistic */ *hadrefp = 0; unfollowed = NULL; rc = count = 0; /* If no referrals in array, return */ if ( (refs == NULL) || ( (refs)[0] == NULL) ) { rc = 0; goto done; } /* Check for hop limit exceeded */ if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) { Debug( LDAP_DEBUG_ANY, "more than %d referral hops (dropping)\n", ld->ld_refhoplimit, 0, 0 ); ld->ld_errno = LDAP_REFERRAL_LIMIT_EXCEEDED; rc = -1; goto done; } /* find original request */ for ( origreq = lr; origreq->lr_parent != NULL; origreq = origreq->lr_parent ) { /* empty */ ; } refarray = refs; refs = NULL; /* parse out & follow referrals */ /* NOTE: if nextref_proc == ldap_int_nextref, params is ignored */ i = -1; for ( nextref_proc( ld, &refarray, &i, ld->ld_nextref_params ); i != -1; nextref_proc( ld, &refarray, &i, ld->ld_nextref_params ) ) { /* Parse the referral URL */ rc = ldap_url_parse_ext( refarray[i], &srv, LDAP_PVT_URL_PARSE_NOEMPTY_DN ); if ( rc != LDAP_URL_SUCCESS ) { /* ldap_url_parse_ext() returns LDAP_URL_* errors * which do not map on API errors */ ld->ld_errno = LDAP_PARAM_ERROR; rc = -1; goto done; } if( srv->lud_crit_exts ) { int ok = 0; #ifdef HAVE_TLS /* If StartTLS is the only critical ext, OK. */ if ( find_tls_ext( srv ) == 2 && srv->lud_crit_exts == 1 ) ok = 1; #endif if ( !ok ) { /* we do not support any other extensions */ ld->ld_errno = LDAP_NOT_SUPPORTED; rc = -1; goto done; } } /* check connection for re-bind in progress */ if (( lc = find_connection( ld, srv, 1 )) != NULL ) { /* See if we've already requested this DN with this conn */ LDAPRequest *lp; int looped = 0; ber_len_t len = srv->lud_dn ? strlen( srv->lud_dn ) : 0; for ( lp = origreq; lp; ) { if ( lp->lr_conn == lc && len == lp->lr_dn.bv_len && len && strncmp( srv->lud_dn, lp->lr_dn.bv_val, len ) == 0 ) { looped = 1; break; } if ( lp == origreq ) { lp = lp->lr_child; } else { lp = lp->lr_refnext; } } if ( looped ) { ldap_free_urllist( srv ); srv = NULL; ld->ld_errno = LDAP_CLIENT_LOOP; rc = -1; continue; } if ( lc->lconn_rebind_inprogress ) { /* We are already chasing a referral or search reference and a * bind on that connection is in progress. We must queue * referrals on that connection, so we don't get a request * going out before the bind operation completes. This happens * if two search references come in one behind the other * for the same server with different contexts. */ Debug( LDAP_DEBUG_TRACE, "ldap_chase_v3referrals: queue referral \"%s\"\n", refarray[i], 0, 0); if( lc->lconn_rebind_queue == NULL ) { /* Create a referral list */ lc->lconn_rebind_queue = (char ***) LDAP_MALLOC( sizeof(void *) * 2); if( lc->lconn_rebind_queue == NULL) { ld->ld_errno = LDAP_NO_MEMORY; rc = -1; goto done; } lc->lconn_rebind_queue[0] = refarray; lc->lconn_rebind_queue[1] = NULL; refarray = NULL; } else { /* Count how many referral arrays we already have */ for( j = 0; lc->lconn_rebind_queue[j] != NULL; j++) { /* empty */; } /* Add the new referral to the list */ lc->lconn_rebind_queue = (char ***) LDAP_REALLOC( lc->lconn_rebind_queue, sizeof(void *) * (j + 2)); if( lc->lconn_rebind_queue == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; rc = -1; goto done; } lc->lconn_rebind_queue[j] = refarray; lc->lconn_rebind_queue[j+1] = NULL; refarray = NULL; } /* We have queued the referral/reference, now just return */ rc = 0; *hadrefp = 1; count = 1; /* Pretend we already followed referral */ goto done; } } /* Re-encode the request with the new starting point of the search. * Note: In the future we also need to replace the filter if one * was provided with the search reference */ /* For references we don't want old dn if new dn empty */ if ( sref && srv->lud_dn == NULL ) { srv->lud_dn = LDAP_STRDUP( "" ); } LDAP_NEXT_MSGID( ld, id ); ber = re_encode_request( ld, origreq->lr_ber, id, sref, srv, &rinfo.ri_request ); if( ber == NULL ) { ld->ld_errno = LDAP_ENCODING_ERROR; rc = -1; goto done; } Debug( LDAP_DEBUG_TRACE, "ldap_chase_v3referral: msgid %d, url \"%s\"\n", lr->lr_msgid, refarray[i], 0); /* Send the new request to the server - may require a bind */ rinfo.ri_msgid = origreq->lr_origid; rinfo.ri_url = refarray[i]; rc = ldap_send_server_request( ld, ber, id, origreq, &srv, NULL, &rinfo, 0, 1 ); if ( rc < 0 ) { /* Failure, try next referral in the list */ Debug( LDAP_DEBUG_ANY, "Unable to chase referral \"%s\" (%d: %s)\n", refarray[i], ld->ld_errno, ldap_err2string( ld->ld_errno ) ); unfollowedcnt += ldap_append_referral( ld, &unfollowed, refarray[i] ); ldap_free_urllist( srv ); srv = NULL; ld->ld_errno = LDAP_REFERRAL; } else { /* Success, no need to try this referral list further */ rc = 0; ++count; *hadrefp = 1; /* check if there is a queue of referrals that came in during bind */ if ( lc == NULL) { lc = find_connection( ld, srv, 1 ); if ( lc == NULL ) { ld->ld_errno = LDAP_OPERATIONS_ERROR; rc = -1; LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex ); goto done; } } if ( lc->lconn_rebind_queue != NULL ) { /* Release resources of previous list */ LDAP_VFREE( refarray ); refarray = NULL; ldap_free_urllist( srv ); srv = NULL; /* Pull entries off end of queue so list always null terminated */ for( j = 0; lc->lconn_rebind_queue[j] != NULL; j++ ) ; refarray = lc->lconn_rebind_queue[j - 1]; lc->lconn_rebind_queue[j-1] = NULL; /* we pulled off last entry from queue, free queue */ if ( j == 1 ) { LDAP_FREE( lc->lconn_rebind_queue ); lc->lconn_rebind_queue = NULL; } /* restart the loop the with new referral list */ i = -1; continue; } break; /* referral followed, break out of for loop */ } } /* end for loop */ done: LDAP_VFREE( refarray ); ldap_free_urllist( srv ); LDAP_FREE( *errstrp ); if( rc == 0 ) { *errstrp = NULL; LDAP_FREE( unfollowed ); return count; } else { *errstrp = unfollowed; return rc; } }
/* process_packet: * Callback which processes a packet captured by libpcap. */ void process_packet(u_char *user, const struct pcap_pkthdr *hdr, const u_char *pkt) { struct tcphdr tcp; int off, len, delta; connection *C, c; struct sockaddr_storage src, dst; struct sockaddr *s, *d; uint8_t proto; s = (struct sockaddr *)&src; d = (struct sockaddr *)&dst; if (handle_link_layer(&datalink_info, pkt, hdr->caplen, &proto, &off)) return; if (layer3_find_tcp(pkt, proto, &off, s, d, &tcp)) return; len = hdr->caplen - off; /* XXX fragmented packets and other nasties. */ /* try to find the connection slot associated with this. */ C = find_connection(s, d); /* no connection at all, so we need to allocate one. */ if (!C) { log_msg(LOG_INFO, "new connection: %s", connection_string(s,d)); C = alloc_connection(); *C = connection_new(s, d); /* This might or might not be an entirely new connection (SYN flag * set). Either way we need a sequence number to start at. */ (*C)->isn = ntohl(tcp.th_seq); } /* Now we need to process this segment. */ c = *C; delta = 0;/*tcp.syn ? 1 : 0;*/ /* NB (STD0007): * SEG.LEN = the number of octets occupied by the data in the * segment (counting SYN and FIN) */ #if 0 if (tcp.syn) /* getting a new isn. */ c->isn = htonl(tcp.seq); #endif if (tcp.th_flags & TH_RST) { /* Looks like this connection is bogus, and so might be a * connection going the other way. */ log_msg(LOG_INFO, "connection reset: %s", connection_string(s, d)); connection_delete(c); *C = NULL; if ((C = find_connection(d, s))) { connection_delete(*C); *C = NULL; } return; } if (len > 0) { /* We have some data in the packet. If this data occurred after * the first data we collected for this connection, then save it * so that we can look for images. Otherwise, discard it. */ unsigned int offset; offset = ntohl(tcp.th_seq); /* Modulo 2**32 arithmetic; offset = seq - isn + delta. */ if (offset < (c->isn + delta)) offset = 0xffffffff - (c->isn + delta - offset); else offset -= c->isn + delta; if (offset > c->len + WRAPLEN) { /* Out-of-order packet. */ log_msg(LOG_INFO, "out of order packet: %s", connection_string(s, d)); } else { connection_push(c, pkt + off, offset, len); extract_media(c); } } if (tcp.th_flags & TH_FIN) { /* Connection closing; mark it as closed, but let sweep_connections * free it if appropriate. */ log_msg(LOG_INFO, "connection closing: %s, %d bytes transferred", connection_string(s, d), c->len); c->fin = 1; } /* sweep out old connections */ sweep_connections(); }
int wait_for_events_and_walk(uber_state_t *uber_state) { struct timeval timeout; event_state_select_t *event_state = uber_state->event_state; fd_set loc_readfds; fd_set loc_writefds; connection_t *temp_connection; int ret; int i; int did_something; timeout.tv_sec = 2; timeout.tv_usec = 0; if (debug) { fprintf(stderr,"about to go into select\n"); } /* rather blunt, but should be effective for now */ memcpy(&loc_readfds, &(event_state->readfds),sizeof(fd_set)); memcpy(&loc_writefds, &(event_state->writefds),sizeof(fd_set)); ret = select(event_state->maxfd + 1, &loc_readfds, &loc_writefds, NULL, /* ignore exception for now */ &timeout); if (debug) { fprintf(stderr, "select returned %d errno %d minfd %d maxfd %d\n", ret, errno, event_state->minfd, event_state->maxfd); } if (ret > 0) { /* first, the reads and accepts */ for (i = event_state->minfd; i <= event_state->maxfd; i++) { if (FD_ISSET(i,&loc_readfds)) { temp_connection = find_connection(uber_state,i); if (debug) { fprintf(stderr, "fd %d is readable on connection %p\n", i, temp_connection); } /* is this our listen endpoint or something else? */ if (temp_connection->flags & CONNECTION_LISTENING ) { /* accept a connection */ SOCKET new_sock; new_sock = accept_new_connection(uber_state, temp_connection); if (INVALID_SOCKET != new_sock) { /* on the very good chance that this new connection is for an FD higher than our listen endpoint, we set loc_readfds so we go ahead and try to read from the new connection when we get to that point in our walk of the fdset returned from select(). */ FD_SET(new_sock,&loc_readfds); } /* if we got one connection, we should see about draining the accept queue, eventually module some limit on the number of concurrent connections we will allow */ while (new_sock >= 0) { new_sock = accept_new_connection(uber_state, temp_connection); if (INVALID_SOCKET != new_sock) { /* on the very good chance that this new connection is for an FD higher than our listen endpoint, we set loc_readfds so we go ahead and try to read from the new connection when we get to that point in our walk of the fdset returned from select(). */ FD_SET(new_sock,&loc_readfds); } } } else if (temp_connection->flags & CONNECTION_READING) { /* read some bytes */ } else { /* something screwy happened */ fprintf(stderr, "YO, we got readable on connection %p but we weren't reading\n", temp_connection); } } } /* now the writes */ for (i = event_state->minfd; i <= event_state->maxfd; i++) { if (FD_ISSET(i,&loc_writefds)) { temp_connection = find_connection(uber_state,i); fprintf(stderr, "fd %d is writable on connection %p\n",i,temp_connection); } } } return 0; }
void test_define(iscsi_test_define_parameters_t *par) { test_pars_t *tp; session_t *sess = NULL; connection_t *conn = NULL; if (!par->test_id) { par->status = ISCSI_STATUS_INVALID_ID; return; } if (find_test_id(par->test_id) != NULL) { par->status = ISCSI_STATUS_DUPLICATE_ID; return; } if (par->session_id && (sess = find_session(par->session_id)) == NULL) { par->status = ISCSI_STATUS_INVALID_SESSION_ID; return; } if (sess != NULL) { if (par->connection_id && (conn = find_connection(sess, par->connection_id)) == NULL) { par->status = ISCSI_STATUS_INVALID_CONNECTION_ID; return; } else if (!par->connection_id) { conn = TAILQ_FIRST(&sess->conn_list); } if (conn->test_pars != NULL) { par->status = ISCSI_STATUS_TEST_ALREADY_ASSIGNED; return; } } if ((tp = malloc(sizeof(*tp), M_TEMP, M_WAITOK | M_ZERO)) == NULL) { par->status = ISCSI_STATUS_NO_RESOURCES; return; } TAILQ_INIT(&tp->negs); TAILQ_INIT(&tp->mods); if (par->neg_descriptor_size && (par->status = add_neg(tp, par->neg_descriptor_ptr, par->neg_descriptor_size)) != 0) { free(tp, M_TEMP); return; } tp->test_id = par->test_id; tp->options = par->options; tp->lose_random[CNT_RX] = par->lose_random_rx; tp->lose_random[CNT_TX] = par->lose_random_tx; tp->connection = conn; tp->firstburst_val = par->firstburst_val; tp->maxburst_val = par->maxburst_val; tp->r2t_val = par->r2t_val; DEB(1, ("TestDefine: id=%d, opt=%x, negsize=%d, conn=%x\n", tp->test_id, tp->options, par->neg_descriptor_size, (int)conn)); TAILQ_INSERT_TAIL(&test_list, tp, link); if (conn != NULL) { tp->connection = conn; conn->test_pars = tp; DEB(1, ("Assigning session %d, connection %d to test %d\n", conn->session->id, conn->id, tp->test_id)); } par->status = ISCSI_STATUS_SUCCESS; }
/* returns the message id of the request or -1 if an error occurs */ int nsldapi_send_server_request( LDAP *ld, /* session handle */ BerElement *ber, /* message to send */ int msgid, /* ID of message to send */ LDAPRequest *parentreq, /* non-NULL for referred requests */ LDAPServer *srvlist, /* servers to connect to (NULL for default) */ LDAPConn *lc, /* connection to use (NULL for default) */ char *bindreqdn, /* non-NULL for bind requests */ int bind /* perform a bind after opening new conn.? */ ) { LDAPRequest *lr; int err; int incparent; /* did we bump parent's ref count? */ LDAPDebug( LDAP_DEBUG_TRACE, "nsldapi_send_server_request\n", 0, 0, 0 ); incparent = 0; LDAP_MUTEX_LOCK( ld, LDAP_CONN_LOCK ); if ( lc == NULL ) { if ( srvlist == NULL ) { if ( ld->ld_defconn == NULL ) { LDAP_MUTEX_LOCK( ld, LDAP_OPTION_LOCK ); if ( bindreqdn == NULL && ( ld->ld_options & LDAP_BITOPT_RECONNECT ) != 0 ) { LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL ); ber_free( ber, 1 ); LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK ); LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); return( -1 ); } LDAP_MUTEX_UNLOCK( ld, LDAP_OPTION_LOCK ); if ( nsldapi_open_ldap_defconn( ld ) < 0 ) { ber_free( ber, 1 ); LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); return( -1 ); } } lc = ld->ld_defconn; } else { if (( lc = find_connection( ld, srvlist, 1 )) == NULL ) { if ( bind && (parentreq != NULL) ) { /* Remember the bind in the parent */ incparent = 1; ++parentreq->lr_outrefcnt; } lc = nsldapi_new_connection( ld, &srvlist, 0, 1, bind ); } free_servers( srvlist ); } } /* * the logic here is: * if * 1. no connections exists, * or * 2. if the connection is either not in the connected * or connecting state in an async io model * or * 3. the connection is notin a connected state with normal (non async io) */ if ( lc == NULL || ( (ld->ld_options & LDAP_BITOPT_ASYNC && lc->lconn_status != LDAP_CONNST_CONNECTING && lc->lconn_status != LDAP_CONNST_CONNECTED) || (!(ld->ld_options & LDAP_BITOPT_ASYNC ) && lc->lconn_status != LDAP_CONNST_CONNECTED) ) ) { ber_free( ber, 1 ); if ( lc != NULL ) { LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL ); } if ( incparent ) { /* Forget about the bind */ --parentreq->lr_outrefcnt; } LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); return( -1 ); } use_connection( ld, lc ); if (( lr = (LDAPRequest *)NSLDAPI_CALLOC( 1, sizeof( LDAPRequest ))) == NULL || ( bindreqdn != NULL && ( bindreqdn = nsldapi_strdup( bindreqdn )) == NULL )) { if ( lr != NULL ) { NSLDAPI_FREE( lr ); } LDAP_SET_LDERRNO( ld, LDAP_NO_MEMORY, NULL, NULL ); nsldapi_free_connection( ld, lc, NULL, NULL, 0, 0 ); ber_free( ber, 1 ); if ( incparent ) { /* Forget about the bind */ --parentreq->lr_outrefcnt; } LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); return( -1 ); } lr->lr_binddn = bindreqdn; lr->lr_msgid = msgid; lr->lr_status = LDAP_REQST_INPROGRESS; lr->lr_res_errno = LDAP_SUCCESS; /* optimistic */ lr->lr_ber = ber; lr->lr_conn = lc; if ( parentreq != NULL ) { /* sub-request */ if ( !incparent ) { /* Increment if we didn't do it before the bind */ ++parentreq->lr_outrefcnt; } lr->lr_origid = parentreq->lr_origid; lr->lr_parentcnt = parentreq->lr_parentcnt + 1; lr->lr_parent = parentreq; if ( parentreq->lr_child != NULL ) { lr->lr_sibling = parentreq->lr_child; } parentreq->lr_child = lr; } else { /* original request */ lr->lr_origid = lr->lr_msgid; } LDAP_MUTEX_LOCK( ld, LDAP_REQ_LOCK ); if (( lr->lr_next = ld->ld_requests ) != NULL ) { lr->lr_next->lr_prev = lr; } ld->ld_requests = lr; lr->lr_prev = NULL; if (( err = nsldapi_ber_flush( ld, lc->lconn_sb, ber, 0, 1 )) != 0 ) { /* need to continue write later */ if (ld->ld_options & LDAP_BITOPT_ASYNC && err == -2 ) { lr->lr_status = LDAP_REQST_WRITING; nsldapi_iostatus_interest_write( ld, lc->lconn_sb ); } else { LDAP_SET_LDERRNO( ld, LDAP_SERVER_DOWN, NULL, NULL ); nsldapi_free_request( ld, lr, 0 ); nsldapi_free_connection( ld, lc, NULL, NULL, 0, 0 ); LDAP_MUTEX_UNLOCK( ld, LDAP_REQ_LOCK ); LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); return( -1 ); } } else { if ( parentreq == NULL ) { ber->ber_end = ber->ber_ptr; ber->ber_ptr = ber->ber_buf; } /* sent -- waiting for a response */ if (ld->ld_options & LDAP_BITOPT_ASYNC) { lc->lconn_status = LDAP_CONNST_CONNECTED; } nsldapi_iostatus_interest_read( ld, lc->lconn_sb ); } LDAP_MUTEX_UNLOCK( ld, LDAP_REQ_LOCK ); LDAP_MUTEX_UNLOCK( ld, LDAP_CONN_LOCK ); LDAP_SET_LDERRNO( ld, LDAP_SUCCESS, NULL, NULL ); return( msgid ); }
/* * Input Device methods */ static DBusMessage *input_device_connect(DBusConnection *conn, DBusMessage *msg, void *data) { //+++ BRCM #ifdef BT_ALT_STACK struct input_device *idev = data; tDTUN_DEVICE_METHOD method; method.hh_open.hdr.id = DTUN_METHOD_HH_OPEN; method.hh_open.hdr.len = sizeof(tDTUN_METHOD_HH_OPEN) - sizeof(tDTUN_HDR); memcpy(&method.hh_open.bdaddr, &idev->dst, 6); read_remote_class(&idev->src, &idev->dst, &method.hh_open.cod); dtun_client_call_method(&method); return NULL; #else struct input_device *idev = data; struct input_conn *iconn; struct fake_input *fake; DBusMessage *reply; GError *err = NULL; iconn = find_connection(idev->connections, "HID"); if (!iconn) return btd_error_not_supported(msg); if (iconn->pending_connect) return btd_error_in_progress(msg); if (is_connected(iconn)) return btd_error_already_connected(msg); iconn->pending_connect = dbus_message_ref(msg); fake = iconn->fake; if (fake) { /* Fake input device */ if (fake->connect(iconn, &err)) fake->flags |= FI_FLAG_CONNECTED; } else { /* HID devices */ GIOChannel *io; io = bt_io_connect(BT_IO_L2CAP, control_connect_cb, iconn, NULL, &err, BT_IO_OPT_SOURCE_BDADDR, &idev->src, BT_IO_OPT_DEST_BDADDR, &idev->dst, BT_IO_OPT_PSM, L2CAP_PSM_HIDP_CTRL, BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_LOW, BT_IO_OPT_POWER_ACTIVE, 0, BT_IO_OPT_INVALID); iconn->ctrl_io = io; } if (err == NULL) return NULL; error("%s", err->message); dbus_message_unref(iconn->pending_connect); iconn->pending_connect = NULL; reply = btd_error_failed(msg, err->message); g_error_free(err); return reply; #endif //--- BRCM }
static int proc_master_connect(int fd, int token, rscntxt_t *cntxt) { Log("proc master connect\n"); connection_t *conn = find_connection(cntxt, token); if (conn == NULL) { Log("Invalid token:%d from the master device\n", token); close (fd); return -1; } int fd_slave = conn->conn_fd; struct sockaddr_in addr; int addr_len = sizeof(addr); if (getpeername(fd, (struct sockaddr *)&addr, &addr_len) < 0) { Log("Failed getsockname of master device"); close (fd); return -1; } uint32 ip = addr.sin_addr.s_addr; int port = addr.sin_port; msgheader_t header; memset(&header, 0, sizeof(header)); header.message_type = htonl(REQ_RELAY); header.ip = ip; header.port = port; int nsize = sizeof(header); if(send(fd_slave, &header, nsize, 0) <= 0) { Log("Failed send resquest relay to slave device\n"); return -1; } Log("sent req_relay to slave device\n"); if (recv(fd_slave, &header, nsize, 0) <= 0) { Log("Failed recv slave device response reply\n"); return -1; } if (header.message_type != RES_RELAY) { Log("Slave device response an invalid reply\n"); return -1; } Log("recv res_relay from slave device\n"); if (getpeername(fd_slave, (struct sockaddr *)&addr, &addr_len) < 0) { Log("Failed getsockname of slave device"); close (fd); return -1; } ip = addr.sin_addr.s_addr; port = addr.sin_port; header.ip = ip; header.port = port; header.token = htonl(token); if (send(fd, &header, nsize, 0) != nsize) { Log("Failed send master response message"); close(fd); return -1; } return 0; }