Exemplo n.º 1
0
template <class key_t, class elem_t> void hash_index<key_t, elem_t>::remove(
        index_handle<key_t, elem_t> the_handle)
  {
    hash_bin_type<key_t, elem_t> *this_bin =
            (hash_bin_type<key_t, elem_t> *)(from_handle(the_handle));
    assert(this_bin != 0);
    if (this_bin->next != 0)
      {
        hash_bin_type<key_t, elem_t> *old_bin = this_bin->next;
        this_bin->the_key = old_bin->the_key;
        this_bin->the_elem = old_bin->the_elem;
        this_bin->next = old_bin->next;
        old_bin->next = 0;
        hash_bin_type<key_t, elem_t>::kill(old_bin);
      }
    else
      {
        size_t bin_num = (*_hash_function)(this_bin->the_key, _table_size);
        hash_bin_type<key_t, elem_t> *first_bin = _table[bin_num];
        assert(first_bin != 0);
        if (first_bin == this_bin)
          {
            _table[bin_num] = 0;
          }
        else
          {
            this_bin->the_key = first_bin->the_key;
            this_bin->the_elem = first_bin->the_elem;
            _table[bin_num] = first_bin->next;
            first_bin->next = 0;
          }
        hash_bin_type<key_t, elem_t>::kill(first_bin);
      }
  }
Exemplo n.º 2
0
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;
}
Exemplo n.º 3
0
/**
 * Connects the given socket to the address.
 * @param sd        The socket handle to connect
 * @param addr      The address to connect to
 * @param addrlen   The length of the address details.
 * @return 0 on success.
 */
sock_result_t socket_connect(sock_handle_t sd, const sockaddr_t *addr, long addrlen)
{
    wiced_result_t result = WICED_INVALID_SOCKET;
    socket_t* socket = from_handle(sd);
    tcp_socket_t* tcp_socket = tcp(socket);
    if (tcp_socket) {
        std::lock_guard<socket_t> lk(*socket);
        result = wiced_tcp_bind(tcp_socket, WICED_ANY_PORT);
        if (result==WICED_SUCCESS) {
            // WICED callbacks are broken
            //wiced_tcp_register_callbacks(tcp(socket), socket_t::notify_connected, socket_t::notify_received, socket_t::notify_disconnected, (void*)socket);
            SOCKADDR_TO_PORT_AND_IPADDR(addr, addr_data, port, ip_addr);
            unsigned timeout = 5*1000;
            result = wiced_tcp_connect(tcp_socket, &ip_addr, port, timeout);
            if (result==WICED_SUCCESS) {
                tcp_socket->connected();
            } else {
              // Work around WICED bug that doesn't set connection handler to NULL after deleting
              // it, leading to deleting the same memory twice and a crash
              // WICED/network/LwIP/WICED/tcpip.c:920
              tcp_socket->conn_handler = NULL;
            }
        }
    }
    return as_sock_result(result);
}
Exemplo n.º 4
0
template <class key_base_t, class elem_t> void
        ts_ptr_index<key_base_t, elem_t>::remove(
                index_handle<key_base_t *, elem_t> the_handle)
  {
    index_handle<const char *, elem_t> tsi_handle;
    tsi_handle.set_raw_referenced_item(from_handle(the_handle));
    _tsi.remove(tsi_handle);
  }
Exemplo n.º 5
0
template <class key_base_t, class elem_t> elem_t
        ts_ptr_index<key_base_t, elem_t>::elem(
                index_handle<key_base_t *, elem_t> the_handle) const
  {
    index_handle<const char *, elem_t> tsi_handle;
    tsi_handle.set_raw_referenced_item(from_handle(the_handle));
    return _tsi.elem(tsi_handle);
  }
Exemplo n.º 6
0
template <class key_t, class elem_t> elem_t alist_index<key_t, elem_t>::
        elem(index_handle<key_t, elem_t> the_handle) const
  {
    alist_holder<key_t, elem_t> *holder =
            (alist_holder<key_t, elem_t> *)(from_handle(the_handle));
    assert(holder != 0);
    return holder->data.the_elem;
  }
Exemplo n.º 7
0
template <class key_t, class elem_t> elem_t hash_index<key_t, elem_t>::elem(
        index_handle<key_t, elem_t> the_handle) const
  {
    hash_bin_type<key_t, elem_t> *this_bin =
            (hash_bin_type<key_t, elem_t> *)(from_handle(the_handle));
    assert(this_bin != 0);
    return this_bin->the_elem;
  }
Exemplo n.º 8
0
template <class elem_t, class holder_t> void
cdlist_tos_base<elem_t, holder_t>::set_elem_by_handle(
    tos_handle<elem_t> the_handle, elem_t the_elem)
{
  holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
  if (elem_ptr == 0)
    return;
  elem_ptr->data = the_elem;
}
Exemplo n.º 9
0
template <class key_t, class elem_t> void alist_index<key_t, elem_t>::
        remove(index_handle<key_t, elem_t> the_handle)
  {
    alist_holder<key_t, elem_t> *holder =
            (alist_holder<key_t, elem_t> *)(from_handle(the_handle));
    assert(holder != 0);
    tos_handle<alist_item<key_t, elem_t> > list_handle = holder;
    _list.remove(list_handle);
  }
Exemplo n.º 10
0
template <class elem_t, class holder_t> tos_handle<elem_t>
adlist_tos_base<elem_t, holder_t>::next_handle(
    tos_handle<elem_t> the_handle) const
{
    holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
    if (elem_ptr == 0)
        return build_handle(0);
    else
        return build_handle(elem_ptr->next);
}
Exemplo n.º 11
0
template <class elem_t, class holder_t> tos_handle<elem_t>
cdlist_tos_base<elem_t, holder_t>::previous_handle(
    tos_handle<elem_t> the_handle) const
{
  holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
  if (elem_ptr == 0)
    return this->build_handle(0);
  else
    return this->build_handle(elem_ptr->previous);
}
Exemplo n.º 12
0
void *odp_shm_addr(odp_shm_t shm)
{
	uint32_t i;

	i = from_handle(shm);

	if (i > (ODP_CONFIG_SHM_BLOCKS - 1))
		return NULL;

	return odp_shm_tbl->block[i].addr;
}
Exemplo n.º 13
0
sock_result_t socket_shutdown(sock_handle_t sd, int how)
{
    sock_result_t result = WICED_ERROR;
    socket_t* socket = from_handle(sd);
    if (socket && is_open(socket) && is_tcp(socket)) {
        std::lock_guard<socket_t> lk(*socket);
        result = wiced_tcp_close_shutdown(tcp(socket), (wiced_tcp_shutdown_flags_t)how);
        LOG_DEBUG(TRACE, "socket shutdown %x %x", sd, how);
    }
    return result;
}
Exemplo n.º 14
0
template <class elem_t, class holder_t> elem_t
cdlist_tos_base<elem_t, holder_t>::elem_by_handle(
    tos_handle<elem_t> the_handle) const
{
  holder_t *elem_ptr =
    (holder_t *)(from_handle(the_handle));
  if (elem_ptr == 0)
    return zero((elem_t *)0);
  else
    return elem_ptr->data;
}
Exemplo n.º 15
0
/**
 * Discards a previously allocated socket. If the socket is already invalid, returns silently.
 * Once a socket has been passed to the client, this is the only time the object is
 * deleted. Since the client initiates this call, the client is aware can the
 * socket is no longer valid.
 * @param handle    The handle to discard.
 * @return SOCKET_INVALID always.
 */
sock_handle_t socket_dispose(sock_handle_t handle) {
    if (socket_handle_valid(handle)) {
        socket_t* socket = from_handle(handle);
        SocketList& list = list_for(socket);
        /* IMPORTANT: SocketListLock is acquired first */
        SocketListLock lock(list);
        std::lock_guard<socket_t> lk(*socket);
        if (list.remove(socket))
            delete socket;
    }
    return SOCKET_INVALID;
}
Exemplo n.º 16
0
/**
 * Closes the socket handle.
 * @param sock
 * @return
 */
sock_result_t socket_close(sock_handle_t sock)
{
    sock_result_t result = WICED_SUCCESS;
    socket_t* socket = from_handle(sock);
    if (socket) {
        {
            std::lock_guard<socket_t> lk(*socket);
            socket->close();
        }
        socket_dispose(sock);
        LOG_DEBUG(TRACE, "socket closed %x", int(sock));
    }
    return result;
}
Exemplo n.º 17
0
template <class elem_t, class holder_t> void
adlist_tos_base<elem_t, holder_t>::insert_before(
    tos_handle<elem_t> the_handle, elem_t the_elem)
{
    holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
    if (elem_ptr == 0)
        return;
    extend_array();
    holder_t *new_e = new holder_t(the_elem, elem_ptr, elem_ptr->previous);
    elem_ptr->previous = new_e;
    if (_head_e == elem_ptr)
        _head_e = new_e;
    else
        new_e->previous->next = new_e;
    _index_size = 0;
    ++_cached_size;
}
Exemplo n.º 18
0
template <class elem_t, class holder_t> void
cdlist_tos_base<elem_t, holder_t>::insert_after(
    tos_handle<elem_t> the_handle, elem_t the_elem)
{
  holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
  if (elem_ptr == 0)
    return;
  holder_t *new_e = new holder_t(the_elem, elem_ptr->next);
  elem_ptr->next = new_e;
  if (_tail_e == elem_ptr)
    _tail_e = new_e;
  else
    new_e->next->previous = new_e;
  _cached_e = _head_e;
  _cached_index = 0;
  ++_cached_size;
}
Exemplo n.º 19
0
int odp_shm_info(odp_shm_t shm, odp_shm_info_t *info)
{
	odp_shm_block_t *block;
	uint32_t i;

	i = from_handle(shm);

	if (i > (ODP_CONFIG_SHM_BLOCKS - 1))
		return -1;

	block = &odp_shm_tbl->block[i];

	info->name = block->name;
	info->addr = block->addr;
	info->size = block->size;
	info->page_size = block->page_sz;
	info->flags = block->flags;

	return 0;
}
Exemplo n.º 20
0
/**
 * Fetch the next waiting client socket from the server
 * @param sock
 * @return
 */
sock_result_t socket_accept(sock_handle_t sock)
{
    sock_result_t result = SOCKET_INVALID;
    socket_t* socket = from_handle(sock);
    if (is_open(socket) && is_server(socket)) {
        std::lock_guard<socket_t> lk(*socket);
        tcp_server_t* server = socket->s.tcp_server;
        tcp_server_client_t* client = server->next_accept();
        if (client) {
            socket_t* socket = new socket_t();
            socket->set_client(client);
            {
                SocketListLock lock(list_for(socket));
                add_socket(socket);
            }
            result = (sock_result_t)socket;
        }
    }
    return result;
}
Exemplo n.º 21
0
/**
 * 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;
}
Exemplo n.º 22
0
template <class elem_t, class holder_t> void
adlist_tos_base<elem_t, holder_t>::remove(
    tos_handle<elem_t> the_handle)
{
    holder_t *elem_ptr = (holder_t *)(from_handle(the_handle));
    if (elem_ptr == 0)
        return;
    if (_head_e == elem_ptr)
        _head_e = elem_ptr->next;
    else
        elem_ptr->previous->next = elem_ptr->next;
    if (_tail_e == elem_ptr)
        _tail_e = elem_ptr->previous;
    else
        elem_ptr->next->previous = elem_ptr->previous;
    elem_ptr->remove_ref();
    if (elem_ptr->delete_me())
        delete elem_ptr;
    _index_size = 0;
    --_cached_size;
}
Exemplo n.º 23
0
sock_result_t socket_receivefrom(sock_handle_t sd, void* buffer, socklen_t bufLen, uint32_t flags, sockaddr_t* addr, socklen_t* addrsize)
{
    socket_t* socket = from_handle(sd);
    volatile wiced_result_t result = WICED_INVALID_SOCKET;
    uint16_t read_len = 0;
    if (is_open(socket) && is_udp(socket)) {
        std::lock_guard<socket_t> lk(*socket);
        wiced_packet_t* packet = NULL;
        // UDP receive timeout changed to 0 sec so as not to block
        if ((result=wiced_udp_receive(udp(socket), &packet, WICED_NO_WAIT))==WICED_SUCCESS) {
            wiced_ip_address_t wiced_ip_addr;
            uint16_t port;
            if ((result=wiced_udp_packet_get_info(packet, &wiced_ip_addr, &port))==WICED_SUCCESS) {
                uint32_t ipv4 = GET_IPV4_ADDRESS(wiced_ip_addr);
                addr->sa_data[0] = (port>>8) & 0xFF;
                addr->sa_data[1] = port & 0xFF;
                addr->sa_data[2] = (ipv4 >> 24) & 0xFF;
                addr->sa_data[3] = (ipv4 >> 16) & 0xFF;
                addr->sa_data[4] = (ipv4 >> 8) & 0xFF;
                addr->sa_data[5] = ipv4 & 0xFF;
                result=read_packet(packet, (uint8_t*)buffer, bufLen, &read_len);
            }
Exemplo n.º 24
0
sock_result_t socket_sendto(sock_handle_t sd, const void* buffer, socklen_t len,
        uint32_t flags, sockaddr_t* addr, socklen_t addr_size)
{
    socket_t* socket = from_handle(sd);
    wiced_result_t result = WICED_INVALID_SOCKET;
    if (is_open(socket) && is_udp(socket)) {
        std::lock_guard<socket_t> lk(*socket);
        SOCKADDR_TO_PORT_AND_IPADDR(addr, addr_data, port, ip_addr);
        uint16_t available = 0;
        wiced_packet_t* packet = NULL;
        uint8_t* data;
        if ((result=wiced_packet_create_udp(udp(socket), len, &packet, &data, &available))==WICED_SUCCESS) {
            size_t size = std::min(available, uint16_t(len));
            memcpy(data, buffer, size);
            /* Set the end of the data portion */
            wiced_packet_set_data_end(packet, (uint8_t*) data + size);
            result = wiced_udp_send(udp(socket), &ip_addr, port, packet);
            len = size;
        }
    }
    // return negative value on error, or length if successful.
    return result ? -result : len;
}
Exemplo n.º 25
0
int odp_shm_free(odp_shm_t shm)
{
	uint32_t i;
	int ret;
	odp_shm_block_t *block;
	char name[ODP_SHM_NAME_LEN + 8];

	if (shm == ODP_SHM_INVALID) {
		ODP_DBG("odp_shm_free: Invalid handle\n");
		return -1;
	}

	i = from_handle(shm);

	if (i >= ODP_CONFIG_SHM_BLOCKS) {
		ODP_DBG("odp_shm_free: Bad handle\n");
		return -1;
	}

	odp_spinlock_lock(&odp_shm_tbl->lock);

	block = &odp_shm_tbl->block[i];

	if (block->addr == NULL) {
		ODP_DBG("odp_shm_free: Free block\n");
		odp_spinlock_unlock(&odp_shm_tbl->lock);
		return 0;
	}

	/* right now, for this tpye of memory, we do nothing as free */
	if (block->flags & ODP_SHM_MONOPOLIZE_CNTNUS_PHY) {
		int pid = getpid();

		snprintf(name, sizeof(name), "%s_%d", block->name, pid);
		odp_mm_district_unreserve(name);
		memset(block, 0, sizeof(odp_shm_block_t));
		odp_spinlock_unlock(&odp_shm_tbl->lock);
		return 0;
	}

	if (block->flags & ODP_SHM_SHARE_CNTNUS_PHY) {
		odp_mm_district_unreserve(name);
		memset(block, 0, sizeof(odp_shm_block_t));
		odp_spinlock_unlock(&odp_shm_tbl->lock);
		return 0;
	}

	ret = munmap(block->addr_orig, block->alloc_size);
	if (0 != ret) {
		ODP_DBG("odp_shm_free: munmap failed: %s, id %u, addr %p\n",
			strerror(errno), i, block->addr_orig);
		odp_spinlock_unlock(&odp_shm_tbl->lock);
		return -1;
	}

	if (block->flags & ODP_SHM_PROC) {
		ret = shm_unlink(block->name);
		if (0 != ret) {
			ODP_DBG("odp_shm_free: shm_unlink failed\n");
			odp_spinlock_unlock(&odp_shm_tbl->lock);
			return -1;
		}
	}

	memset(block, 0, sizeof(odp_shm_block_t));
	odp_spinlock_unlock(&odp_shm_tbl->lock);
	return 0;
}
Exemplo n.º 26
0
 // Initialize from std handle.
 void from_stdin() { from_handle(stdin_handle()); m_file_name = "[stdin]"; }
Exemplo n.º 27
0
 void from_stdout() { from_handle(stdout_handle()); m_file_name = "[stdout]"; }
Exemplo n.º 28
0
 void from_stderr() { from_handle(stderr_handle()); m_file_name = "[stderr]"; }
Exemplo n.º 29
0
/**
 * Determines if a given socket is bound.
 * @param sd    The socket handle to test
 * @return non-zero if bound, 0 otherwise.
 */
uint8_t socket_active_status(sock_handle_t sd)
{
    socket_t* socket = from_handle(sd);
    return (socket && socket->isOpen()) ? SOCKET_STATUS_ACTIVE : SOCKET_STATUS_INACTIVE;
}