int xmmsc_ipc_io_in_callback (xmmsc_ipc_t *ipc) { bool disco = false; x_return_val_if_fail (ipc, false); x_return_val_if_fail (!ipc->disconnect, false); while (!disco) { if (!ipc->read_msg) ipc->read_msg = xmms_ipc_msg_alloc (); if (xmms_ipc_msg_read_transport (ipc->read_msg, ipc->transport, &disco)) { xmms_ipc_msg_t *msg = ipc->read_msg; /* must unset read_msg here, because exec_msg can cause reentrancy */ ipc->read_msg = NULL; xmmsc_ipc_exec_msg (ipc, msg); } else { break; } } if (disco) xmmsc_ipc_disconnect (ipc); return !disco; }
xPointer x_bytes_unref_to_data(xBytes *bytes, xSize *size) { xPointer result; x_return_val_if_fail(bytes != NULL, NULL); x_return_val_if_fail(size != NULL, NULL); /* * Optimal path: if this is was the last reference, then we can return * the data from this xBytes without copying. */ result = try_steal_and_unref(bytes, free, size); if (result == NULL) { /* * Copy: Non malloc (or compatible) allocater, or static memory, * so we have to copy, and then unref. */ result = memdup(bytes->data, bytes->size); *size = bytes->size; x_bytes_unref(bytes); } return result; }
int xmmsc_ipc_io_out_callback (xmmsc_ipc_t *ipc) { bool disco = false; x_return_val_if_fail (ipc, false); x_return_val_if_fail (!ipc->disconnect, false); while (!x_queue_is_empty (ipc->out_msg)) { xmms_ipc_msg_t *msg = x_queue_peek_head (ipc->out_msg); if (xmms_ipc_msg_write_transport (msg, ipc->transport, &disco)) { x_queue_pop_head (ipc->out_msg); xmms_ipc_msg_destroy (msg); } else { break; } } if (disco) { xmmsc_ipc_disconnect (ipc); } else { if (ipc->need_out_callback) ipc->need_out_callback (xmmsc_ipc_io_out (ipc), ipc->need_out_data); } return !disco; }
xBytes* x_bytes_new_from_bytes(xBytes *bytes, xSize offset, xSize length) { /* Note that length may be 0. */ x_return_val_if_fail(bytes != NULL, NULL); x_return_val_if_fail(offset <= bytes->size, NULL); x_return_val_if_fail(offset + length <= bytes->size, NULL); return x_bytes_new_with_free_func((xChar*)bytes->data + offset, length, x_bytes_unref, x_bytes_ref(bytes)); }
xBoolean x_bytes_equal(xConstPointer bytes1, xConstPointer bytes2) { const xBytes *b1 = bytes1; const xBytes *b2 = bytes2; x_return_val_if_fail(bytes1 != NULL, FALSE); x_return_val_if_fail(bytes2 != NULL, FALSE); return b1->size == b2->size && memcmp(b1->data, b2->data, b1->size) == 0; }
xInt32 x_serialport_read(xSerialPort *port, xUInt8 *buffer, xInt32 count) { x_return_val_if_fail(port, -1); x_return_val_if_fail(buffer, -1); x_return_val_if_fail(count > 0, -1); if (!x_serialport_is_open(port)) return -1; return x_serialport_platform_read(port->platform, buffer, count); }
/** * Try to read message from transport into msg. * * @returns TRUE if message is fully read. */ bool xmms_ipc_msg_read_transport (xmms_ipc_msg_t *msg, xmms_ipc_transport_t *transport, bool *disconnected) { char buf[512]; unsigned int ret, len, rlen; x_return_val_if_fail (msg, false); x_return_val_if_fail (transport, false); while (true) { len = XMMS_IPC_MSG_HEAD_LEN; if (msg->xfered >= XMMS_IPC_MSG_HEAD_LEN) { len += xmms_ipc_msg_get_length (msg); if (msg->xfered == len) { return true; } } x_return_val_if_fail (msg->xfered < len, false); rlen = len - msg->xfered; if (rlen > sizeof (buf)) rlen = sizeof (buf); ret = xmms_ipc_transport_read (transport, buf, rlen); if (ret == SOCKET_ERROR) { if (xmms_socket_error_recoverable ()) { return false; } if (disconnected) { *disconnected = true; } return false; } else if (ret == 0) { if (disconnected) { *disconnected = true; } return false; } else { xmmsv_bitbuffer_goto (msg->bb, msg->xfered * 8); xmmsv_bitbuffer_put_data (msg->bb, (unsigned char *) buf, ret); msg->xfered += ret; xmmsv_bitbuffer_goto (msg->bb, XMMS_IPC_MSG_HEAD_LEN * 8); } } }
xBoolean x_serialport_set_write_buffer_size(xSerialPort *port, xInt32 value) { x_return_val_if_fail(port, FALSE); x_return_val_if_fail(value > 0, FALSE); if (x_serialport_is_open(port)) return FALSE; port->write_buffer_size = value; return TRUE; }
xBoolean x_serialport_set_port_name(xSerialPort *port, const xChar *value) { x_return_val_if_fail(port, FALSE); x_return_val_if_fail(value, FALSE); if (x_serialport_is_open(port)) return FALSE; port->port_name = x_string_assign(port->port_name, value); return TRUE; }
static int xmms_ipc_tcp_write (xmms_ipc_transport_t *ipct, char *buffer, int len) { xmms_socket_t fd; x_return_val_if_fail (ipct, -1); x_return_val_if_fail (buffer, -1); fd = ipct->fd; return send (fd, buffer, len, 0); }
bool xmmsc_ipc_connect (xmmsc_ipc_t *ipc, char *path) { x_return_val_if_fail (ipc, false); x_return_val_if_fail (path, false); ipc->transport = xmms_ipc_client_init (path); if (!ipc->transport) { ipc->error = strdup ("Could not init client!"); return false; } return true; }
static int xmms_ipc_tcp_read (xmms_ipc_transport_t *ipct, char *buffer, int len) { xmms_socket_t fd; int ret; x_return_val_if_fail (ipct, -1); x_return_val_if_fail (buffer, -1); fd = ipct->fd; ret = recv (fd, buffer, len, 0); return ret; }
xInt x_bytes_compare(xConstPointer bytes1, xConstPointer bytes2) { const xBytes *b1 = bytes1; const xBytes *b2 = bytes2; xInt ret; x_return_val_if_fail(bytes1 != NULL, 0); x_return_val_if_fail(bytes2 != NULL, 0); ret = memcmp(b1->data, b2->data, MIN(b1->size, b2->size)); if (ret == 0 && b1->size != b2->size) ret = b1->size < b2->size ? -1 : 1; return ret; }
/** * Remove the value at a given index from the idlist. * @param coll The collection to update. * @param index The index at which to remove the value. * @return TRUE on success, false otherwise. */ int xmmsv_coll_idlist_remove (xmmsv_t *coll, int index) { x_return_val_if_fail (coll, 0); return xmmsv_list_remove (coll->value.coll->idlist, index); }
int xmmsc_ipc_io_out (xmmsc_ipc_t *ipc) { x_return_val_if_fail (ipc, false); return !x_queue_is_empty (ipc->out_msg) && !ipc->disconnect; }
/** * Empties the idlist. * @param coll The collection to update. * @return TRUE on success, false otherwise. */ int xmmsv_coll_idlist_clear (xmmsv_t *coll) { x_return_val_if_fail (coll, 0); return xmmsv_list_clear (coll->value.coll->idlist); }
xmmsv_t * xmmsv_coll_operands_get (xmmsv_t *coll) { x_return_val_if_fail (coll, NULL); return coll->value.coll->operands; }
/** * Sets the value at the given position in the idlist. * @param coll The collection to update. * @param index The position of the value to set. * @param val The new value. * @return TRUE on success, false otherwise. */ int xmmsv_coll_idlist_set_index (xmmsv_t *coll, int index, int64_t val) { x_return_val_if_fail (coll, 0); return xmmsv_list_set_int (coll->value.coll->idlist, index, val); }
bool x_queue_is_empty (x_queue_t *queue) { x_return_val_if_fail (queue, true); return queue->head == NULL; }
void * x_queue_peek_tail (x_queue_t *queue) { x_return_val_if_fail (queue, NULL); return queue->tail ? queue->tail->data : NULL; }
/** * Return the type of the collection. * @param coll The collection to consider. * @return The #xmmsv_coll_type_t of the collection, or -1 if invalid. */ xmmsv_coll_type_t xmmsv_coll_get_type (xmmsv_t *coll) { x_return_val_if_fail (coll, -1); return coll->value.coll->type; }
/** * Append a value to the idlist. * @param coll The collection to update. * @param id The id to append to the idlist. * @return TRUE on success, false otherwise. */ int xmmsv_coll_idlist_append (xmmsv_t *coll, int64_t id) { x_return_val_if_fail (coll, 0); return xmmsv_list_append_int (coll->value.coll->idlist, id); }
/** * Allocate a new collection of the given type. * The pointer will have to be deallocated using #xmmsv_coll_unref. * * @param type the #xmmsv_coll_type_t specifying the type of collection to create. * @return a pointer to the newly created collection, or NULL if the type is invalid. */ static xmmsv_coll_internal_t* _xmmsv_coll_new (xmmsv_coll_type_t type) { xmmsv_coll_internal_t *coll; x_return_val_if_fail (type <= XMMS_COLLECTION_TYPE_LAST, NULL); coll = x_new0 (xmmsv_coll_internal_t, 1); if (!coll) { x_oom (); return NULL; } coll->type = type; coll->idlist = xmmsv_new_list (); xmmsv_list_restrict_type (coll->idlist, XMMSV_TYPE_INT64); coll->operands = xmmsv_new_list (); xmmsv_list_restrict_type (coll->operands, XMMSV_TYPE_COLL); coll->attributes = xmmsv_new_dict (); return coll; }
xBoolean x_serialport_open(xSerialPort *port) { x_return_val_if_fail(port, FALSE); if (x_serialport_is_open(port)) return FALSE; if (port->platform != NULL) x_serialport_platform_free(port->platform); port->platform = x_serialport_platform_new(); if (!x_serialport_platform_open(port->platform, port->port_name->str, port->baudrate, port->parity, port->databits, port->stopbits, port->read_timeout, port->write_timeout, port->handshake, port->dtr_enable, port->rts_enable, FALSE, '\0')) return FALSE; x_serialport_platform_set_buffer_sizes(port->platform, port->read_buffer_size, port->write_buffer_size); return TRUE; }
xmmsv_t * xmmsv_coll_attributes_get (xmmsv_t *coll) { x_return_val_if_fail (coll, NULL); return coll->value.coll->attributes; }
/** * Returns a collection with a LIMIT operator added * * @param coll The collection to add the limit operator to * @param lim_start The index of the first element to include, or 0 to disable * @param lim_len The length of the interval, or 0 to disable * @return A new collection with LIMIT operator added */ xmmsv_t * xmmsv_coll_add_limit_operator (xmmsv_t *coll, int lim_start, int lim_len) { xmmsv_t *ret; char str[12]; x_return_val_if_fail (lim_start >= 0 && lim_len >= 0, NULL); if (lim_start == 0 && lim_len == 0) { return xmmsv_ref (coll); } ret = xmmsv_new_coll (XMMS_COLLECTION_TYPE_LIMIT); xmmsv_coll_add_operand (ret, coll); if (lim_start != 0) { int count = snprintf (str, sizeof (str), "%i", lim_start); if (count > 0 && count < sizeof (str)) { xmmsv_coll_attribute_set_string (ret, "start", str); } else { x_api_warning ("could not set collection limit operator start"); } } if (lim_len != 0) { int count = snprintf (str, sizeof (str), "%i", lim_len); if (count > 0 && count < sizeof (str)) { xmmsv_coll_attribute_set_string (ret, "length", str); } else { x_api_warning ("could not set collection limit operator length"); } } return ret; }
/** * Insert a value at a given position in the idlist. * @param coll The collection to update. * @param id The id to insert in the idlist. * @param index The position at which to insert the value. * @return TRUE on success, false otherwise. */ int xmmsv_coll_idlist_insert (xmmsv_t *coll, int index, int64_t id) { x_return_val_if_fail (coll, 0); return xmmsv_list_insert_int (coll->value.coll->idlist, index, id); }
void * x_queue_peek_head (x_queue_t *queue) { x_return_val_if_fail (queue, NULL); return queue->head ? queue->head->data : NULL; }
xConstPointer x_bytes_get_data(xBytes *bytes, xSize *size) { x_return_val_if_fail(bytes != NULL, NULL); if (size) *size = bytes->size; return bytes->data; }
/** * Get the size of the idlist. * @param coll The collection to update. * @return The size of the idlist. */ int xmmsv_coll_idlist_get_size (xmmsv_t *coll) { x_return_val_if_fail (coll, 0); return xmmsv_list_get_size (coll->value.coll->idlist); }