bool rpc_session::on_disconnected(bool is_write) { bool ret; if (set_disconnected()) { rpc_session_ptr sp = this; if (is_client()) { _net.on_client_session_disconnected(sp); } else { _net.on_server_session_disconnected(sp); } ret = true; } else { ret = false; } if (is_write) { clear_send_queue(false); } return ret; }
void rpc_session::start_read_next(int read_next) { // server only if (!is_client()) { int delay_ms = 0; { utils::auto_lock<utils::ex_lock_nr> l(_lock); delay_ms = _delay_server_receive_ms; _delay_server_receive_ms = 0; } // delayed read if (delay_ms > 0) { auto delay_task = dsn_task_create( LPC_DELAY_RPC_REQUEST_RATE, __delayed_rpc_session_read_next__, this ); this->add_ref(); // released in __delayed_rpc_session_read_next__ dsn_task_call(delay_task, delay_ms); } else { do_read(read_next); } } else { do_read(read_next); } }
sock_result_t socket_send_ex(sock_handle_t sd, const void* buffer, socklen_t len, uint32_t flags, system_tick_t timeout, void* reserved) { sock_result_t result = SOCKET_INVALID; socket_t* socket = from_handle(sd); uint16_t bytes_sent = 0; if (is_open(socket)) { std::lock_guard<socket_t> lk(*socket); wiced_result_t wiced_result = WICED_TCPIP_INVALID_SOCKET; if (is_tcp(socket)) { wiced_tcp_send_flags_t wiced_flags = timeout == 0 ? WICED_TCP_SEND_FLAG_NONBLOCK : WICED_TCP_SEND_FLAG_NONE; bytes_sent = (uint16_t)len; wiced_result = wiced_tcp_send_buffer_ex(tcp(socket), buffer, &bytes_sent, wiced_flags, timeout); } else if (is_client(socket)) { tcp_server_client_t* server_client = client(socket); size_t written = 0; wiced_result = server_client->write(buffer, len, &written, flags, timeout); bytes_sent = (uint16_t)written; } if (!wiced_result) DEBUG("Write %d bytes to socket %d result=%d", (int)len, (int)sd, wiced_result); result = wiced_result ? as_sock_result(wiced_result) : bytes_sent; } return result; }
/** * Returns true if a window can be automatically focused, or false otherwise. */ bool ClientModel::is_autofocusable(Window client) { if (!is_client(client)) return false; return m_autofocus[client]; }
/** * Either allows, or prevents, a client from being autofocused. */ void ClientModel::set_autofocus(Window client, bool can_autofocus) { if (!is_client(client)) return; m_autofocus[client] = can_autofocus; }
/** * Changes the current desktop to the desktop before the current. */ void ClientModel::prev_desktop() { // We have to add the maximum desktops back in, since C++ doesn't // guarantee what will happen with a negative modulus unsigned long long desktop_index = (m_current_desktop->desktop - 1 + m_max_desktops) % m_max_desktops; // We can't change while a window is being moved or resized if (m_desktops.count_members_of(MOVING_DESKTOP) > 0 || m_desktops.count_members_of(RESIZING_DESKTOP) > 0) return; UserDesktop* old_desktop = m_current_desktop; m_current_desktop = USER_DESKTOPS[desktop_index]; Window old_focus = m_focused; if (m_focused != None) { if (is_child(m_focused) && !is_visible(get_parent_of(m_focused))) unfocus(false); if (is_client(m_focused) && !is_visible(m_focused)) unfocus(false); } m_changes.push(new ChangeCurrentDesktop(old_desktop, m_current_desktop)); // If we can still focus the window we were focused on before, then do so // Otherwise, figure out the next logical window in the focus cycle if (m_focused != None && m_focused == old_focus) m_current_desktop->focus_cycle.set(m_focused); else sync_focus_to_cycle(); }
bool is_msm_hw3d_file(struct file *file) { struct hw3d_info *info = hw3d_info; if (MAJOR(file->f_dentry->d_inode->i_rdev) == MAJOR(info->devno) && (is_master(info, file) || is_client(info, file))) return 1; return 0; }
wiced_tcp_socket_t* as_wiced_tcp_socket(socket_t* socket) { if (is_tcp(socket)) { return tcp(socket); } else if (is_client(socket)) { return socket->s.tcp_client->get_socket(); } return NULL; }
bool rpc_session::on_recv_message(message_ex* msg, int delay_ms) { if (msg->header->from_address.is_invalid()) msg->header->from_address = _remote_addr; msg->to_address = _net.address(); msg->io_session = this; if (msg->header->context.u.is_request) { // ATTENTION: need to check if self connection occurred. // // When we try to connect some socket in the same host, if we don't bind the client to a specific port, // operating system will provide ephemeral port for us. If it's happened to be the one we want to connect to, // it causes self connection. // // The case is: // - this session is a client session // - the remote address is in the same host // - the remote address is not listened, which means the remote port is not occupied // - operating system chooses the remote port as client's ephemeral port if (is_client() && msg->header->from_address == _net.engine()->primary_address()) { derror("self connection detected, address = %s", msg->header->from_address.to_string()); dassert(msg->get_count() == 0, "message should not be referenced by anybody so far"); delete msg; return false; } dbg_dassert(!is_client(), "only rpc server session can recv rpc requests"); _net.on_recv_request(msg, delay_ms); } // both rpc server session and rpc client session can receive rpc reply // specially, rpc client session can receive general rpc reply, // and rpc server session can receive forwarded rpc reply else { _matcher->on_recv_reply(&_net, msg->header->id, msg, delay_ms); } return true; }
/* * A libdevinfo di_walk_node() callback. It's passed an integer pointer as an * argument, and it increments the integer each time it encounters an MPxIO * client. By initializing the integer to zero and doing a libdevinfo walk with * this function, the total count of MPxIO clients in the system can be found. */ static int get_nclients(di_node_t dinode, void *arg) { int *nclients = arg; if (is_client(dinode)) (*nclients)++; return (DI_WALK_CONTINUE); }
/** * Gets the children of a client. */ void ClientModel::get_children_of(Window client, std::vector<Window> &return_children) { if (!is_client(client)) return; for (std::set<Window>::iterator child = m_children[client]->begin(); child != m_children[client]->end(); child++) { return_children.push_back(*child); } }
void rpc_session::set_connected() { dassert(is_client(), "must be client session"); { utils::auto_lock<utils::ex_lock_nr> l(_lock); dassert(_connect_state == SS_CONNECTING, "session must be connecting"); _connect_state = SS_CONNECTED; } rpc_session_ptr sp = this; _net.on_client_session_connected(sp); }
/** * Removes a client. * * Note that this method will put out a ChangeFocus event, but that event will * have a nonexistent 'prev_focus' field (pointing to the client that is * destroyed). Other than that event, however, no other notification will be * delivered that this window was removed. */ void ClientModel::remove_client(Window client) { if (!is_client(client)) return; // Unregister the client from any categories it may be a member of, but // keep a copy of each of the categories so we can pass it on to notify // that the window was destroyed (don't copy the size/location though, // since they will most likely be invalid, and of no use anyway) Desktop *desktop = find_desktop(client); Layer layer = find_layer(client); if (desktop->is_user_desktop()) { UserDesktop *user_desktop = dynamic_cast<UserDesktop*>(desktop); user_desktop->focus_cycle.remove(client, true); sync_focus_to_cycle(); } else if (desktop->is_all_desktop()) { dynamic_cast<AllDesktops*>(ALL_DESKTOPS)->focus_cycle.remove(client, true); sync_focus_to_cycle(); } // Make sure to remove the child before removing any other parent state - the // child removal procedure depends upon knowing the parent's desktop std::set<Window> children(*m_children[client]); for (std::set<Window>::iterator child = children.begin(); child != children.end(); child++) { remove_child(*child, false); } m_desktops.remove_member(client); m_layers.remove_member(client); m_location.erase(client); m_size.erase(client); m_cps_mode.erase(client); m_screen.erase(client); m_autofocus.erase(client); m_pack_corners.erase(client); m_pack_priority.erase(client); delete m_children[client]; m_children.erase(client); m_changes.push(new DestroyChange(client, desktop, layer)); }
bool rpc_session::try_connecting() { dassert(is_client(), "must be client session"); utils::auto_lock<utils::ex_lock_nr> l(_lock); if (_connect_state == SS_DISCONNECTED) { _connect_state = SS_CONNECTING; return true; } else { return false; } }
/** * Adds a new child window to the given client. */ void ClientModel::add_child(Window client, Window child) { if (!is_client(client)) return; if (is_child(child)) return; m_children[client]->insert(child); m_parents[child] = client; m_changes.push(new ChildAddChange(client, child)); if (is_autofocusable(client)) { m_current_desktop->focus_cycle.add_after(child, client); focus(child); } }
void rpc_session::on_recv_message(message_ex* msg, int delay_ms) { msg->to_address = _net.address(); msg->io_session = this; if (msg->header->context.u.is_request) { dbg_dassert(!is_client(), "only rpc server session can recv rpc requests"); _net.on_recv_request(msg, delay_ms); } // both rpc server session and rpc client session can receive rpc reply // specially, rpc client session can receive general rpc reply, // and rpc server session can receive forwarded rpc reply else { _matcher->on_recv_reply(&_net, msg->header->id, msg, delay_ms); } }
/** * Receives data from a socket. * @param sd * @param buffer * @param len * @param _timeout * @return The number of bytes read. -1 if the end of the stream is reached. */ sock_result_t socket_receive(sock_handle_t sd, void* buffer, socklen_t len, system_tick_t _timeout) { sock_result_t bytes_read = -1; socket_t* socket = from_handle(sd); if (is_open(socket)) { std::lock_guard<socket_t> lk(*socket); if (is_tcp(socket)) { tcp_socket_t* tcp_socket = tcp(socket); tcp_packet_t& packet = tcp_socket->packet; bytes_read = read_packet_and_dispose(packet, buffer, len, tcp_socket, _timeout); } else if (is_client(socket)) { tcp_server_client_t* server_client = client(socket); bytes_read = read_packet_and_dispose(server_client->packet, buffer, len, server_client->get_socket(), _timeout); } } if (bytes_read<0) DEBUG("socket_receive on %d returned %d", sd, bytes_read); return bytes_read; }
/** * Handles an existing client that was unmapped, and is now being re-mapped. */ void ClientModel::remap_client(Window client) { if (!is_client(client)) return; std::vector<Window> children; get_children_of(client, children); Desktop *desktop = find_desktop(client); if (desktop->is_user_desktop()) { UserDesktop *user_desktop = dynamic_cast<UserDesktop*>(desktop); user_desktop->focus_cycle.add(client); for (std::vector<Window>::iterator child = children.begin(); child != children.end(); child++) { user_desktop->focus_cycle.add(*child); } focus(client); } else if (desktop->is_all_desktop()) { AllDesktops *all_desktop = dynamic_cast<AllDesktops*>(ALL_DESKTOPS); all_desktop->focus_cycle.add(client); for (std::vector<Window>::iterator child = children.begin(); child != children.end(); child++) { all_desktop->focus_cycle.add(*child); } focus(client); } // The event processor also needs to know that it should update the current // layering, since the window could have been raised since it was remapped Layer current_layer = m_layers.get_category_of(client); m_changes.push(new ChangeLayer(client, current_layer)); }
/** * Changes the focus to another window. Note that this fails if the client * is not currently visible. * * This is used for automated focusing, and is subject to the rules of * autofocusing - in particular, if the user enables nofocus for this type of * window, then this will do nothing. */ void ClientModel::focus(Window client) { Window parent = client; if (is_child(client)) parent = get_parent_of(client); if (!is_client(parent)) return; if (!is_visible(parent)) return; if (!m_autofocus[parent]) return; Window old_focus = m_focused; m_focused = client; m_current_desktop->focus_cycle.set(client); m_changes.push(new ChangeFocus(old_focus, client)); }
/* * Initialize and return open socket. */ static int init(void) { int sockfd; uint32_t lport; uint32_t rport; char lhost[NI_MAXHOST]; char rhost[NI_MAXHOST]; if (is_client()) client_get_hosts(lhost, rhost); else server_get_hosts(lhost, rhost); sockfd = rds_socket(lhost, Req.port); lport = get_socket_port(sockfd); encode_uint32(&lport, lport); send_mesg(&lport, sizeof(lport), "RDS port"); recv_mesg(&rport, sizeof(rport), "RDS port"); rport = decode_uint32(&rport); rds_makeaddr(&RAddr, &RLen, rhost, rport); return sockfd; }
bool rpc_session::on_disconnected(bool is_write) { if (is_client()) { set_disconnected(); rpc_session_ptr sp = this; _net.on_client_session_disconnected(sp); } else { rpc_session_ptr sp = this; _net.on_server_session_disconnected(sp); } if (is_write) { clear_send_queue(false); } return true; }
/* * Open a RDMA device. */ int rd_open(DEVICE *dev, int trans, int max_send_wr, int max_recv_wr) { #if 0 /* Send request to client */ if (is_client()) client_send_request(); #endif /* Clear structure */ memset(dev, 0, sizeof(*dev)); /* Set transport type and maximum work request parameters */ #if 0 dev->trans = trans; #endif dev->max_send_wr = max_send_wr; dev->max_recv_wr = max_recv_wr; /* Open device */ #if 0 if (Req.use_cm) cm_open(dev); else #endif int r = ib_open(dev); if (r != 0) { return r; } /* Request CQ notification if not polling */ if (!Req.poll_mode) { if (ibv_req_notify_cq(dev->cq, 0) != 0) return error(SYS, "failed to request CQ notification"); } return r; }
/** * This is just a way of directly sending an event to the ClientModel - we * don't do anything with it. */ void ClientModel::unmap_client(Window client) { if (!is_client(client)) return; std::vector<Window> children; get_children_of(client, children); Desktop *desktop = find_desktop(client); if (desktop->is_user_desktop()) { UserDesktop *user_desktop = dynamic_cast<UserDesktop*>(desktop); for (std::vector<Window>::iterator child = children.begin(); child != children.end(); child++) { user_desktop->focus_cycle.remove(*child, false); } user_desktop->focus_cycle.remove(client, false); sync_focus_to_cycle(); } else if (desktop->is_all_desktop()) { AllDesktops *all_desktop = dynamic_cast<AllDesktops*>(ALL_DESKTOPS); for (std::vector<Window>::iterator child = children.begin(); child != children.end(); child++) { all_desktop->focus_cycle.remove(*child, false); } all_desktop->focus_cycle.remove(client, false); sync_focus_to_cycle(); } m_changes.push(new UnmapChange(client)); }
static int dissect_gopher(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { proto_item *ti; proto_tree *gopher_tree, *dir_tree = NULL; gboolean client = is_client(pinfo); gint line_len; const gchar *request = "[Invalid request]"; gboolean is_dir = FALSE; gint offset = 0, next_offset; gint sel_start, host_start, port_start; gchar *name; /* Fill in our protocol and info columns */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "Gopher"); if (client) { line_len = tvb_find_line_end(tvb, 0, -1, NULL, FALSE); if (line_len == 0) { request = "[Directory list]"; } else if (line_len > 0) { request = tvb_get_ephemeral_string(tvb, 0, line_len); } col_add_fstr(pinfo->cinfo, COL_INFO, "Request: %s", request); } else { col_add_fstr(pinfo->cinfo, COL_INFO, "Response"); } if (tree) { /* Create display subtree for the protocol */ ti = proto_tree_add_item(tree, proto_gopher, tvb, 0, -1, ENC_NA); gopher_tree = proto_item_add_subtree(ti, ett_gopher); if (client) { proto_item_append_text(ti, " request: %s", request); proto_tree_add_string(gopher_tree, hf_gopher_request, tvb, 0, -1, request); } else { proto_item_append_text(ti, " response: "); while (find_dir_tokens(tvb, offset + 1, &sel_start, &host_start, &port_start, &line_len, &next_offset)) { if (!is_dir) { /* First time */ proto_item_append_text(ti, "[Directory list]"); col_append_fstr(pinfo->cinfo, COL_INFO, ": [Directory list]"); } name = tvb_get_string(tvb, offset + 1, sel_start - offset - 2); ti = proto_tree_add_string(gopher_tree, hf_gopher_dir_item, tvb, offset, line_len + 1, name); g_free(name); dir_tree = proto_item_add_subtree(ti, ett_dir_item); proto_tree_add_item(dir_tree, hf_gopher_di_type, tvb, offset, 1, ENC_BIG_ENDIAN); proto_tree_add_item(dir_tree, hf_gopher_di_name, tvb, offset + 1, sel_start - offset - 2, ENC_ASCII|ENC_NA); proto_tree_add_item(dir_tree, hf_gopher_di_selector, tvb, sel_start, host_start - sel_start - 1, ENC_ASCII|ENC_NA); proto_tree_add_item(dir_tree, hf_gopher_di_host, tvb, host_start, port_start - host_start - 1, ENC_ASCII|ENC_NA); proto_tree_add_item(dir_tree, hf_gopher_di_port, tvb, port_start, line_len - (port_start - offset - 1), ENC_ASCII|ENC_NA); is_dir = TRUE; offset = next_offset; } if (!is_dir) { proto_item_append_text(ti, "[Unknown]"); proto_tree_add_item(gopher_tree, hf_gopher_unknown, tvb, 0, -1, ENC_ASCII|ENC_NA); } } } /* Return the amount of data this dissector was able to dissect */ return tvb_length(tvb); }
remain -= *host_start - *sel_start; *port_start = tvb_find_guint8(tvb, *host_start, remain, '\t') + 1; if (*port_start < *host_start + 1) return FALSE; return TRUE; } /* Dissect the packets */ static int dissect_gopher(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) { proto_item *ti; proto_tree *gopher_tree, *dir_tree = NULL; gboolean client = is_client(pinfo); gint line_len; const gchar *request = "[Invalid request]"; gboolean is_dir = FALSE; gint offset = 0, next_offset; gint sel_start, host_start, port_start; gchar *name; /* Fill in our protocol and info columns */ col_set_str(pinfo->cinfo, COL_PROTOCOL, "Gopher"); if (client) { line_len = tvb_find_line_end(tvb, 0, -1, NULL, FALSE); if (line_len == 0) { request = "[Directory list]"; } else if (line_len > 0) {
/** * Find the index of the given client socket in our list of client sockets. * @param socket The socket to find. * @return The index of the socket (>=0) or -1 if not found. */ int index(wiced_tcp_socket_t* socket) { return (is_client(socket)) ? socket-this->WICED_SOCKET_ARRAY : -1; }
inline tcp_server_client_t* client(socket_t* socket) { return is_client(socket) ? socket->s.tcp_client : NULL; }