void test_queue_peek_head(void) { Queue *queue; /* Check peeking into an empty queue */ queue = queue_new(); assert(queue_peek_head(queue) == NULL); queue_free(queue); /* Pop off all the values from the queue, making sure that peek * has the correct value beforehand */ queue = generate_queue(); while (!queue_is_empty(queue)) { assert(queue_peek_head(queue) == &variable4); assert(queue_pop_head(queue) == &variable4); assert(queue_peek_head(queue) == &variable3); assert(queue_pop_head(queue) == &variable3); assert(queue_peek_head(queue) == &variable2); assert(queue_pop_head(queue) == &variable2); assert(queue_peek_head(queue) == &variable1); assert(queue_pop_head(queue) == &variable1); } assert(queue_peek_head(queue) == NULL); queue_free(queue); }
static struct att_send_op *pick_next_send_op(struct bt_att *att) { struct att_send_op *op; /* See if any operations are already in the write queue */ op = queue_pop_head(att->write_queue); if (op) return op; /* If there is no pending request, pick an operation from the * request queue. */ if (!att->pending_req) { op = queue_pop_head(att->req_queue); if (op) return op; } /* There is either a request pending or no requests queued. If there is * no pending indication, pick an operation from the indication queue. */ if (!att->pending_ind) { op = queue_pop_head(att->ind_queue); if (op) return op; } return NULL; }
static void process_read_by_type(struct async_read_op *op) { struct bt_gatt_server *server = op->server; uint8_t ecode; struct gatt_db_attribute *attr; attr = queue_pop_head(op->db_data); if (op->done || !attr) { bt_att_send(server->att, BT_ATT_OP_READ_BY_TYPE_RSP, op->pdu, op->pdu_len, NULL, NULL, NULL); async_read_op_destroy(op); return; } ecode = check_permissions(server, attr, BT_ATT_PERM_READ | BT_ATT_PERM_READ_AUTHEN | BT_ATT_PERM_READ_ENCRYPT); if (ecode) goto error; if (gatt_db_attribute_read(attr, 0, op->opcode, server->att, read_by_type_read_complete_cb, op)) return; ecode = BT_ATT_ERROR_UNLIKELY; error: bt_att_send_error_rsp(server->att, BT_ATT_OP_READ_BY_TYPE_REQ, gatt_db_attribute_get_handle(attr), ecode); async_read_op_destroy(op); }
/* Drop a packet from the longest queue in 'rl'. */ static void drop_packet(struct rate_limiter *rl) { struct ofp_queue *longest; /* Queue currently selected as longest. */ int n_longest; /* # of queues of same length as 'longest'. */ struct ofp_queue *q; longest = &rl->queues[0]; n_longest = 1; for (q = &rl->queues[0]; q < &rl->queues[OFPP_MAX]; q++) { if (longest->n < q->n) { longest = q; n_longest = 1; } else if (longest->n == q->n) { n_longest++; /* Randomly select one of the longest queues, with a uniform * distribution (Knuth algorithm 3.4.2R). */ if (!random_range(n_longest)) { longest = q; } } } /* FIXME: do we want to pop the tail instead? */ ofpbuf_delete(queue_pop_head(longest)); rl->n_queued--; }
void *queue_remove(struct queue *queue, void *data) { struct list *entry; if ( !queue->head ) return NULL; entry = list_find(queue->head, data); if ( NULL == entry ) { // We didnt find this entry return NULL; } // This entry is there in the list if ( queue->head == entry ) { // This is the first node data = queue_pop_head(queue); return data; } else if ( queue->tail == entry ) { // This is the tail node data = queue_pop_tail(queue); return data; } // This is and arbitary location, between head and tail queue->length--; __list_remove(entry, entry); __list_free(entry); return data; }
void test_queue_is_empty(void) { Queue *queue; queue = queue_new(); assert(queue_is_empty(queue)); queue_push_head(queue, &variable1); assert(!queue_is_empty(queue)); queue_pop_head(queue); assert(queue_is_empty(queue)); queue_push_tail(queue, &variable1); assert(!queue_is_empty(queue)); queue_pop_tail(queue); assert(queue_is_empty(queue)); queue_free(queue); }
static bool encode_read_by_grp_type_rsp(struct gatt_db *db, struct queue *q, struct bt_att *att, uint16_t mtu, uint8_t *pdu, uint16_t *len) { int iter = 0; uint16_t start_handle, end_handle; struct iovec value; uint8_t data_val_len; *len = 0; while (queue_peek_head(q)) { struct gatt_db_attribute *attrib = queue_pop_head(q); value.iov_base = NULL; value.iov_len = 0; /* * This should never be deferred to the read callback for * primary/secondary service declarations. */ if (!gatt_db_attribute_read(attrib, 0, BT_ATT_OP_READ_BY_GRP_TYPE_REQ, att, attribute_read_cb, &value) || !value.iov_len) return false; /* * Use the first attribute to determine the length of each * attribute data unit. Stop the list when a different attribute * value is seen. */ if (iter == 0) { data_val_len = MIN(MIN((unsigned)mtu - 6, 251), value.iov_len); pdu[0] = data_val_len + 4; iter++; } else if (value.iov_len != data_val_len) break; /* Stop if this unit would surpass the MTU */ if (iter + data_val_len + 4 > mtu - 1) break; gatt_db_attribute_get_service_handles(attrib, &start_handle, &end_handle); put_le16(start_handle, pdu + iter); put_le16(end_handle, pdu + iter + 2); memcpy(pdu + iter + 4, value.iov_base, data_val_len); iter += data_val_len + 4; } *len = iter; return true; }
void test_queue_push_head(void) { Queue *queue; int i; queue = queue_new(); /* Add some values */ for (i=0; i<1000; ++i) { queue_push_head(queue, &variable1); queue_push_head(queue, &variable2); queue_push_head(queue, &variable3); queue_push_head(queue, &variable4); } assert(!queue_is_empty(queue)); /* Check values come out of the tail properly */ assert(queue_pop_tail(queue) == &variable1); assert(queue_pop_tail(queue) == &variable2); assert(queue_pop_tail(queue) == &variable3); assert(queue_pop_tail(queue) == &variable4); /* Check values come back out of the head properly */ assert(queue_pop_head(queue) == &variable4); assert(queue_pop_head(queue) == &variable3); assert(queue_pop_head(queue) == &variable2); assert(queue_pop_head(queue) == &variable1); queue_free(queue); /* Test behavior when running out of memory. */ queue = queue_new(); alloc_test_set_limit(0); assert(!queue_push_head(queue, &variable1)); queue_free(queue); }
/*get picture from vo_queue,remove*/ AVPicture_t *dtvideo_output_read (void *priv) { dtvideo_context_t *vctx = (dtvideo_context_t *) priv; queue_t *picture_queue = vctx->vo_queue; if (picture_queue->length == 0) { return NULL; } return queue_pop_head (picture_queue); }
void queue_free (Queue* queue) { /* Empty the queue */ while (!queue_is_empty (queue)) { queue_pop_head (queue); } /* Free back the queue */ free (queue); }
static bool encode_find_info_rsp(struct gatt_db *db, struct queue *q, uint16_t mtu, uint8_t *pdu, uint16_t *len) { uint16_t handle; struct gatt_db_attribute *attr; const bt_uuid_t *type; int uuid_len, cur_uuid_len; int iter = 0; *len = 0; while (queue_peek_head(q)) { attr = queue_pop_head(q); handle = gatt_db_attribute_get_handle(attr); type = gatt_db_attribute_get_type(attr); if (!handle || !type) return false; cur_uuid_len = bt_uuid_len(type); if (iter == 0) { switch (cur_uuid_len) { case 2: uuid_len = 2; pdu[0] = 0x01; break; case 4: case 16: uuid_len = 16; pdu[0] = 0x02; break; default: return false; } iter++; } else if (cur_uuid_len != uuid_len) break; if (iter + uuid_len + 2 > mtu - 1) break; put_le16(handle, pdu + iter); bt_uuid_to_le(type, pdu + iter + 2); iter += uuid_len + 2; } *len = iter; return true; }
void test_queue_pop_head(void) { Queue *queue; /* Check popping off an empty queue */ queue = queue_new(); assert(queue_pop_head(queue) == NULL); queue_free(queue); /* Pop off all the values from the queue */ queue = generate_queue(); while (!queue_is_empty(queue)) { assert(queue_pop_head(queue) == &variable4); assert(queue_pop_head(queue) == &variable3); assert(queue_pop_head(queue) == &variable2); assert(queue_pop_head(queue) == &variable1); } assert(queue_pop_head(queue) == NULL); queue_free(queue); }
static bool can_write_data(struct io *io, void *user_data) { struct mgmt *mgmt = user_data; struct mgmt_request *request; ssize_t bytes_written; request = queue_pop_head(mgmt->reply_queue); if (!request) { /* only reply commands can jump the queue */ if (!queue_isempty(mgmt->pending_list)) return false; request = queue_pop_head(mgmt->request_queue); if (!request) return false; } bytes_written = write(mgmt->fd, request->buf, request->len); if (bytes_written < 0) { util_debug(mgmt->debug_callback, mgmt->debug_data, "write failed: %s", strerror(errno)); if (request->callback) request->callback(MGMT_STATUS_FAILED, 0, NULL, request->user_data); destroy_request(request); return true; } util_debug(mgmt->debug_callback, mgmt->debug_data, "[0x%04x] command 0x%04x", request->index, request->opcode); util_hexdump('<', request->buf, bytes_written, mgmt->debug_callback, mgmt->debug_data); queue_push_tail(mgmt->pending_list, request); return false; }
static bool io_write_callback(struct io *io, void *user_data) { struct bt_hci *hci = user_data; struct cmd *cmd; cmd = queue_pop_head(hci->cmd_queue); if (cmd) { send_command(hci, cmd->opcode, cmd->data, cmd->size); queue_push_tail(hci->rsp_queue, cmd); } hci->writer_active = false; return false; }
/* Remove and return the next packet to transmit (in round-robin order). */ static struct ofpbuf * dequeue_packet(struct rate_limiter *rl) { unsigned int i; for (i = 0; i < OFPP_MAX; i++) { unsigned int port = (rl->next_tx_port + i) % OFPP_MAX; struct ofp_queue *q = &rl->queues[port]; if (q->n) { rl->next_tx_port = (port + 1) % OFPP_MAX; rl->n_queued--; return queue_pop_head(q); } } NOT_REACHED(); }
static void exec_next_prep_write(struct bt_gatt_server *server, uint16_t ehandle, int err) { struct prep_write_data *next = NULL; struct gatt_db_attribute *attr; bool status; if (err) goto error; next = queue_pop_head(server->prep_queue); if (!next) { bt_att_send(server->att, BT_ATT_OP_EXEC_WRITE_RSP, NULL, 0, NULL, NULL, NULL); return; } attr = gatt_db_get_attribute(server->db, next->handle); if (!attr) { err = BT_ATT_ERROR_UNLIKELY; goto error; } status = gatt_db_attribute_write(attr, next->offset, next->value, next->length, BT_ATT_OP_EXEC_WRITE_REQ, server->att, exec_write_complete_cb, server); prep_write_data_destroy(next); if (status) return; err = BT_ATT_ERROR_UNLIKELY; error: queue_remove_all(server->prep_queue, NULL, NULL, prep_write_data_destroy); bt_att_send_error_rsp(server->att, BT_ATT_OP_EXEC_WRITE_REQ, ehandle, err); }
static void process_read_by_type(struct async_read_op *op) { struct bt_gatt_server *server = op->server; uint8_t ecode; struct gatt_db_attribute *attr; uint32_t perm; attr = queue_pop_head(op->db_data); if (op->done || !attr) { bt_att_send(server->att, BT_ATT_OP_READ_BY_TYPE_RSP, op->pdu, op->pdu_len, NULL, NULL, NULL); async_read_op_destroy(op); return; } perm = gatt_db_attribute_get_permissions(attr); /* * Check for the READ access permission. Encryption, * authentication, and authorization permissions need to be * checked by the read handler, since bt_att is agnostic to * connection type and doesn't have security information on it. */ if (perm && !(perm & BT_ATT_PERM_READ)) { ecode = BT_ATT_ERROR_READ_NOT_PERMITTED; goto error; } if (gatt_db_attribute_read(attr, 0, op->opcode, server->att, read_by_type_read_complete_cb, op)) return; ecode = BT_ATT_ERROR_UNLIKELY; error: bt_att_send_error_rsp(server->att, BT_ATT_OP_READ_BY_TYPE_REQ, gatt_db_attribute_get_handle(attr), ecode); async_read_op_destroy(op); }
static void end_element( void *ud, const xmlChar *xname) { char *name = (char*)xname; parse_data_t *pd = (parse_data_t*)ud; int id; union { int id; void * pid; } start_id; int ii; // Check to see if the first element found has been closed // If so, ignore any junk following it. if (pd->closed_top) return; for (ii = 0; ii < TAG_MAP_SZ; ii++) { if (strcmp(name, tag_map[ii].tag) == 0) { id = tag_map[ii].id; break; } } if (ii == TAG_MAP_SZ) { hb_error("Unrecognized start tag (%s)", name); return; } start_id.pid = queue_pop_head(pd->tag_stack); if (start_id.id != id) hb_error("start tag != end tag: (%s %d) %d", name, id, id); hb_value_t *gval = NULL; hb_value_t *current = queue_peek_head(pd->stack); hb_value_type_t gtype = 0; const char *value; if (pd->value != NULL) value = pd->value; else value = ""; switch (id) { case P_PLIST: { // Ignore } break; case P_KEY: { if (pd->key) free(pd->key); pd->key = strdup(value); return; } break; case P_DICT: { queue_pop_head(pd->stack); } break; case P_ARRAY: { queue_pop_head(pd->stack); } break; case P_INTEGER: { uint64_t val = strtoll(value, NULL, 0); gval = hb_value_int(val); } break; case P_REAL: { double val = strtod(value, NULL); gval = hb_value_double(val); } break; case P_STRING: { gval = hb_value_string(value); } break; case P_TRUE: { gval = hb_value_bool(1); } break; case P_FALSE: { gval = hb_value_bool(0); } break; default: { hb_error("Unhandled plist type %d", id); } break; } if (gval) { // Get the top of the data structure stack and if it's an array // or dict, add the current element if (current == NULL) { pd->plist = gval; pd->closed_top = 1; return; } gtype = hb_value_type(current); if (gtype == HB_VALUE_TYPE_ARRAY) { hb_value_array_append(current, gval); } else if (gtype == HB_VALUE_TYPE_DICT) { if (pd->key == NULL) { hb_error("No key for dictionary item"); hb_value_free(&gval); } else { hb_dict_set(current, pd->key, gval); } } else { hb_error("Invalid container type. This shouldn't happen"); } } if (queue_is_empty(pd->stack)) pd->closed_top = 1; }