Changeset 849ed54 in mainline for uspace/lib


Ignore:
Timestamp:
2010-03-30T18:39:04Z (15 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
7553689
Parents:
7d6fe4db
Message:

Networking work:
Split the networking stack into end-user library (libsocket) and two helper libraries (libnet and libnetif).
Don't use over-the-hand compiling and linking, but rather separation of conserns.
There might be still some issues and the non-modular networking architecture is currently broken, but this will be fixed soon.

Location:
uspace/lib
Files:
7 added
89 moved

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/adt/module_map.c

    r7d6fe4db r849ed54  
    4141#include <ipc/services.h>
    4242
    43 #include "../err.h"
    44 #include "../modules.h"
     43#include <net_err.h>
     44#include <net_modules.h>
    4545
    46 #include "generic_char_map.h"
    47 #include "module_map.h"
     46#include <adt/generic_char_map.h>
     47#include <adt/module_map.h>
    4848
    4949GENERIC_CHAR_MAP_IMPLEMENT(modules, module_t)

  • uspace/lib/net/generic/net_checksum.c

    r7d6fe4db r849ed54  
    3737#include <sys/types.h>
    3838
    39 #include "include/checksum.h"
     39#include <net_checksum.h>
    4040
    4141/** Big-endian encoding CRC divider.

  • uspace/lib/net/generic/net_remote.c

    r7d6fe4db r849ed54  
    4040#include <malloc.h>
    4141
    42 #include "../messages.h"
    43 #include "../modules.h"
    44 
    45 #include "../include/device.h"
    46 #include "../include/net_interface.h"
    47 
    48 #include "../structures/measured_strings.h"
    49 
    50 #include "net_messages.h"
     42#include <net_messages.h>
     43#include <net_modules.h>
     44#include <net_device.h>
     45#include <net_interface.h>
     46#include <adt/measured_strings.h>
     47#include <net_net_messages.h>
    5148
    5249int net_connect_module(services_t service){

  • uspace/lib/net/generic/packet_remote.c

    r7d6fe4db r849ed54  
    3838#include <async.h>
    3939#include <errno.h>
    40 
    4140#include <ipc/ipc.h>
    4241#include <sys/mman.h>
    4342
    44 #include "../../err.h"
    45 #include "../../messages.h"
    46 
    47 #include "packet.h"
    48 #include "packet_client.h"
    49 #include "packet_header.h"
    50 #include "packet_messages.h"
     43#include <net_err.h>
     44#include <net_messages.h>
     45#include <packet/packet.h>
     46#include <packet/packet_client.h>
     47#include <packet/packet_header.h>
     48#include <packet/packet_messages.h>
    5149
    5250/** Obtains the packet from the packet server as the shared memory block.

  • uspace/lib/net/il/arp_remote.c

    r7d6fe4db r849ed54  
    3838#include <async.h>
    3939#include <errno.h>
    40 
    4140#include <ipc/ipc.h>
    4241#include <ipc/services.h>
    4342
    44 #include "../../messages.h"
    45 #include "../../modules.h"
    46 
    47 #include "../../include/device.h"
    48 #include "../../include/arp_interface.h"
    49 
    50 #include "../../structures/measured_strings.h"
    51 
    52 #include "arp_messages.h"
     43#include <net_messages.h>
     44#include <net_modules.h>
     45#include <net_device.h>
     46#include <arp_interface.h>
     47#include <adt/measured_strings.h>
     48#include <arp_messages.h>
    5349
    5450int arp_connect_module(services_t service){

  • uspace/lib/net/il/ip_client.c

    r7d6fe4db r849ed54  
    3737
    3838#include <errno.h>
    39 
    4039#include <sys/types.h>
    4140
    42 #include "../../include/ip_client.h"
    43 #include "../../include/socket_errno.h"
    44 
    45 #include "../../structures/packet/packet.h"
    46 #include "../../structures/packet/packet_client.h"
    47 
    48 #include "ip_header.h"
     41#include <ip_client.h>
     42#include <socket_errno.h>
     43#include <packet/packet.h>
     44#include <packet/packet_client.h>
     45#include <ip_header.h>
    4946
    5047size_t ip_client_header_length(packet_t packet){

  • uspace/lib/net/il/ip_remote.c

    r7d6fe4db r849ed54  
    3939#include <ipc/services.h>
    4040
    41 #include "../../messages.h"
    42 #include "../../modules.h"
    43 
    44 #include "../../include/device.h"
    45 #include "../../include/inet.h"
    46 #include "../../include/ip_interface.h"
    47 
    48 #include "../../structures/packet/packet_client.h"
    49 
    50 #include "../il_messages.h"
    51 
    52 #include "ip_messages.h"
     41#include <net_messages.h>
     42#include <net_modules.h>
     43#include <net_device.h>
     44#include <inet.h>
     45#include <ip_interface.h>
     46#include <packet/packet_client.h>
     47#include <il_messages.h>
     48#include <ip_messages.h>
    5349
    5450int ip_add_route_req(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway){

  • uspace/lib/net/include/adt/module_map.h

    r7d6fe4db r849ed54  
    4242#include <ipc/services.h>
    4343
    44 #include "../modules.h"
     44#include <net_modules.h>
    4545
    46 #include "generic_char_map.h"
     46#include <adt/generic_char_map.h>
    4747
    4848/** Type definition of the module structure.

  • uspace/lib/net/include/arp_interface.h

    r7d6fe4db r849ed54  
    4141#define __NET_ARP_INTERFACE_H__
    4242
    43 #include "../structures/measured_strings.h"
    44 
    45 #include "device.h"
     43#include <adt/measured_strings.h>
     44#include <net_device.h>
    4645
    4746/** @name ARP module interface
    … …  
    6766 *  @returns Other error codes as defined for the nil_get_broadcast_addr() function.
    6867 */
    69 int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address);
     68extern int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address);
    7069
    7170/** Translates the given protocol address to the network interface address.
    … …  
    8382 *  @returns ENOENT if the mapping is not found.
    8483 */
    85 int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data);
     84extern int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data);
    8685
    8786/** Clears the device cache.
    … …  
    9190 *  @returns ENOENT if the device is not found.
    9291 */
    93 int arp_clear_device_req(int arp_phone, device_id_t device_id);
     92extern int arp_clear_device_req(int arp_phone, device_id_t device_id);
    9493
    9594/** Clears the given protocol address from the cache.
    … …  
    101100 *  @returns ENOENT if the mapping is not found.
    102101 */
    103 int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address);
     102extern int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address);
    104103
    105104/** Cleans the cache.
    … …  
    107106 *  @returns EOK on success.
    108107 */
    109 int arp_clean_cache_req(int arp_phone);
     108extern int arp_clean_cache_req(int arp_phone);
    110109
    111110/** Connects to the ARP module.
    … …  
    114113 *  @returns 0 if called by the bundle module.
    115114 */
    116 int arp_connect_module(services_t service);
     115extern int arp_connect_module(services_t service);
    117116
    118117/** Returns the ARP task identifier.
    … …  
    120119 *  @returns 0 if called by the remote module.
    121120 */
    122 task_id_t arp_task_get_id(void);
     121extern task_id_t arp_task_get_id(void);
    123122
    124123/*@}*/

  • uspace/lib/net/include/arp_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../../messages.h"
     43#include <net_messages.h>
    4444
    4545/** ARP module messages.

  • uspace/lib/net/include/icmp_client.h

    r7d6fe4db r849ed54  
    3838#define __NET_ICMP_CLIENT_H__
    3939
    40 #include "icmp_codes.h"
    41 #include "../structures/packet/packet.h"
     40#include <icmp_codes.h>
     41#include <packet/packet.h>
    4242
    4343/** Processes the received packet prefixed with an ICMP header.
    … …  
    5050 *  @returns Zero (0) if the packet contains no data.
    5151 */
    52 int icmp_client_process_packet(packet_t packet, icmp_type_t * type, icmp_code_t * code, icmp_param_t * pointer, icmp_param_t * mtu);
     52extern int icmp_client_process_packet(packet_t packet, icmp_type_t * type, icmp_code_t * code, icmp_param_t * pointer, icmp_param_t * mtu);
    5353
    5454/** Returns the ICMP header length.
    … …  
    5656 *  @returns The ICMP header length in bytes.
    5757 */
    58 size_t icmp_client_header_length(packet_t packet);
     58extern size_t icmp_client_header_length(packet_t packet);
    5959
    6060#endif

  • uspace/lib/net/include/icmp_header.h

    r7d6fe4db r849ed54  
    4141#include <sys/types.h>
    4242
    43 #include "../../include/in.h"
    44 #include "../../include/icmp_codes.h"
     43#include <in.h>
     44#include <icmp_codes.h>
    4545
    4646/** ICMP header size in bytes.

  • uspace/lib/net/include/icmp_interface.h

    r7d6fe4db r849ed54  
    4343#include <sys/types.h>
    4444
    45 #include "device.h"
    46 
    47 #include "../structures/measured_strings.h"
    48 #include "../structures/packet/packet.h"
    49 
    50 #include "inet.h"
    51 #include "ip_codes.h"
    52 #include "socket_codes.h"
    53 
    54 #include "icmp_codes.h"
    55 #include "icmp_common.h"
     45#include <net_device.h>
     46#include <adt/measured_strings.h>
     47#include <packet/packet.h>
     48#include <inet.h>
     49#include <ip_codes.h>
     50#include <socket_codes.h>
     51#include <icmp_codes.h>
     52#include <icmp_common.h>
    5653
    5754/** @name ICMP module interface
    … …  
    7168 *  @returns ENOMEM if there is not enough memory left.
    7269 */
    73 int icmp_destination_unreachable_msg(int icmp_phone, icmp_code_t code, icmp_param_t mtu, packet_t packet);
     70extern int icmp_destination_unreachable_msg(int icmp_phone, icmp_code_t code, icmp_param_t mtu, packet_t packet);
    7471
    7572/** Sends the Source Quench error notification packet.
    … …  
    8279 *  @returns ENOMEM if there is not enough memory left.
    8380 */
    84 int icmp_source_quench_msg(int icmp_phone, packet_t packet);
     81extern int icmp_source_quench_msg(int icmp_phone, packet_t packet);
    8582
    8683/** Sends the Time Exceeded error notification packet.
    … …  
    9491 *  @returns ENOMEM if there is not enough memory left.
    9592 */
    96 int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t packet);
     93extern int icmp_time_exceeded_msg(int icmp_phone, icmp_code_t code, packet_t packet);
    9794
    9895/** Sends the Parameter Problem error notification packet.
    … …  
    107104 *  @returns ENOMEM if there is not enough memory left.
    108105 */
    109 int icmp_parameter_problem_msg(int icmp_phone, icmp_code_t code, icmp_param_t pointer, packet_t packet);
     106extern int icmp_parameter_problem_msg(int icmp_phone, icmp_code_t code, icmp_param_t pointer, packet_t packet);
    110107
    111108/*@}*/

  • uspace/lib/net/include/il_interface.h

    r7d6fe4db r849ed54  
    4343#include <ipc/services.h>
    4444
    45 #include "../messages.h"
    46 
    47 #include "../include/device.h"
    48 
    49 #include "../structures/packet/packet.h"
    50 #include "../structures/packet/packet_client.h"
    51 
    52 #include "../il/il_messages.h"
     45#include <net_messages.h>
     46#include <net_device.h>
     47#include <packet/packet.h>
     48#include <packet/packet_client.h>
     49#include <il_messages.h>
    5350
    5451/** @name Internetwork layer module interface

  • uspace/lib/net/include/ip_client.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "../structures/packet/packet.h"
    43 
    44 #include "ip_codes.h"
    45 #include "ip_interface.h"
    46 #include "socket_codes.h"
     42#include <packet/packet.h>
     43#include <ip_codes.h>
     44#include <ip_interface.h>
     45#include <socket_codes.h>
    4746
    4847/** Prepares the packet to be transfered via IP.
    … …  
    5756 *  @returns ENOMEM if there is not enough memory left in the packet.
    5857 */
    59 int ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length);
     58extern int ip_client_prepare_packet(packet_t packet, ip_protocol_t protocol, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, size_t ipopt_length);
    6059
    6160/** Processes the received IP packet.
    … …  
    7170 *  @returns ENOMEM if the packet is too short to contain the IP header.
    7271 */
    73 int ip_client_process_packet(packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length);
     72extern int ip_client_process_packet(packet_t packet, ip_protocol_t * protocol, ip_ttl_t * ttl, ip_tos_t * tos, int * dont_fragment, size_t * ipopt_length);
    7473
    7574/** Returns the IP header length.
    … …  
    7877 *  @returns Zero (0) if there is no IP header.
    7978 */
    80 size_t ip_client_header_length(packet_t packet);
     79extern size_t ip_client_header_length(packet_t packet);
    8180
    8281/** Updates the IPv4 pseudo header data length field.
    … …  
    8887 *  @returns EINVAL if the headerlen parameter is not IPv4 pseudo header length.
    8988 */
    90 int ip_client_set_pseudo_header_data_length(ip_pseudo_header_ref header, size_t headerlen, size_t data_length);
     89extern int ip_client_set_pseudo_header_data_length(ip_pseudo_header_ref header, size_t headerlen, size_t data_length);
    9190
    9291/** Constructs the IPv4 pseudo header.
    … …  
    108107 *  @returns ENOMEM if there is not enough memory left.
    109108 */
    110 int ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, ip_pseudo_header_ref * header, size_t * headerlen);
     109extern int ip_client_get_pseudo_header(ip_protocol_t protocol, struct sockaddr * src, socklen_t srclen, struct sockaddr * dest, socklen_t destlen, size_t data_length, ip_pseudo_header_ref * header, size_t * headerlen);
    111110
    112111// TODO ipopt manipulation

  • uspace/lib/net/include/ip_interface.h

    r7d6fe4db r849ed54  
    4242
    4343#include <async.h>
    44 
    4544#include <ipc/services.h>
    4645
    47 #include "../include/device.h"
     46#include <net_device.h>
     47#include <packet/packet.h>
    4848
    49 #include "../structures/packet/packet.h"
    50 
    51 #include "in.h"
    52 #include "ip_codes.h"
    53 #include "socket_codes.h"
     49#include <in.h>
     50#include <ip_codes.h>
     51#include <socket_codes.h>
    5452
    5553/** @name IP module interface
    … …  
    8280 *  @returns Other error codes as defined for the bind_service() function.
    8381 */
    84 int ip_bind_service(services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t tl_received_msg);
     82extern int ip_bind_service(services_t service, int protocol, services_t me, async_client_conn_t receiver, tl_received_msg_t tl_received_msg);
    8583
    8684/** Registers the new device.
    … …  
    9896 *  @returns Other error codes as defined for the arp_device_req() function.
    9997 */
    100 int ip_device_req(int ip_phone, device_id_t device_id, services_t netif);
     98extern int ip_device_req(int ip_phone, device_id_t device_id, services_t netif);
    10199
    102100/** Sends the packet queue.
    … …  
    110108 *  @returns Other error codes as defined for the generic_send_msg() function.
    111109 */
    112 int ip_send_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error);
     110extern int ip_send_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t sender, services_t error);
    113111
    114112/** Connects to the IP module.
    … …  
    117115 *  @returns 0 if called by the bundle module.
    118116 */
    119 int ip_connect_module(services_t service);
     117extern int ip_connect_module(services_t service);
    120118
    121119/** Adds a route to the device routing table.
    … …  
    127125 *  @param[in] gateway The target network gateway. Not used if zero.
    128126 */
    129 int ip_add_route_req(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway);
     127extern int ip_add_route_req(int ip_phone, device_id_t device_id, in_addr_t address, in_addr_t netmask, in_addr_t gateway);
    130128
    131129/** Sets the default gateway.
    … …  
    135133 *  @param[in] gateway The default gateway.
    136134 */
    137 int ip_set_gateway_req(int ip_phone, device_id_t device_id, in_addr_t gateway);
     135extern int ip_set_gateway_req(int ip_phone, device_id_t device_id, in_addr_t gateway);
    138136
    139137/** Returns the device packet dimension for sending.
    … …  
    145143 *  @returns Other error codes as defined for the generic_packet_size_req() function.
    146144 */
    147 int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension);
     145extern int ip_packet_size_req(int ip_phone, device_id_t device_id, packet_dimension_ref packet_dimension);
    148146
    149147/** Notifies the IP module about the received error notification packet.
    … …  
    155153 *  @returns EOK on success.
    156154 */
    157 int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error);
     155extern int ip_received_error_msg(int ip_phone, device_id_t device_id, packet_t packet, services_t target, services_t error);
    158156
    159157/** Returns the device identifier and the IP pseudo header based on the destination address.
    … …  
    166164 *  @param[out] headerlen The IP pseudo header length.
    167165 */
    168 int ip_get_route_req(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen);
     166extern int ip_get_route_req(int ip_phone, ip_protocol_t protocol, const struct sockaddr * destination, socklen_t addrlen, device_id_t * device_id, ip_pseudo_header_ref * header, size_t * headerlen);
    169167
    170168/*@}*/

  • uspace/lib/net/include/ip_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../../include/in.h"
    44 #include "../../include/ip_codes.h"
     43#include <in.h>
     44#include <ip_codes.h>
    4545
    4646/** IP module messages.

  • uspace/lib/net/include/net_checksum.h

    r7d6fe4db r849ed54  
    6565 *  @returns The computed CRC32 of the length bits of the data.
    6666 */
    67 uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length);
     67extern uint32_t compute_crc32_le(uint32_t seed, uint8_t * data, size_t length);
    6868
    6969/**     Computes CRC32 value in the big-endian environment.
    … …  
    7373 *  @returns The computed CRC32 of the length bits of the data.
    7474 */
    75 uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length);
     75extern uint32_t compute_crc32_be(uint32_t seed, uint8_t * data, size_t length);
    7676
    7777/** Computes sum of the 2 byte fields.
    … …  
    8282 *  @returns The computed checksum of the length bytes of the data.
    8383 */
    84 uint32_t compute_checksum(uint32_t seed, uint8_t * data, size_t length);
     84extern uint32_t compute_checksum(uint32_t seed, uint8_t * data, size_t length);
    8585
    8686/** Compacts the computed checksum to the 16 bit number adding the carries.
    … …  
    8888 *  @returns Compacted computed checksum to the 16 bits.
    8989 */
    90 uint16_t compact_checksum(uint32_t sum);
     90extern uint16_t compact_checksum(uint32_t sum);
    9191
    9292/** Returns or flips the checksum if zero.
    … …  
    9595 *  @returns 0xFFFF if the computed checksum is zero.
    9696 */
    97 uint16_t flip_checksum(uint16_t checksum);
     97extern uint16_t flip_checksum(uint16_t checksum);
    9898
    9999/** Computes the ip header checksum.
    … …  
    106106 *  @returns 0xFFFF if the computed checksum is zero.
    107107 */
    108 uint16_t ip_checksum(uint8_t * data, size_t length);
     108extern uint16_t ip_checksum(uint8_t * data, size_t length);
    109109
    110110#endif

  • uspace/lib/net/include/net_interface.h

    r7d6fe4db r849ed54  
    4343#include <ipc/services.h>
    4444
    45 #include "../include/device.h"
    46 
    47 #include "../structures/measured_strings.h"
     45#include <net_device.h>
     46#include <adt/measured_strings.h>
    4847
    4948/** @name Networking module interface
    … …  
    6665 *  @returns Other error codes as defined for the generic_translate_req() function.
    6766 */
    68 int net_get_device_conf_req(int net_phone, device_id_t device_id, measured_string_ref * configuration, size_t count, char ** data);
     67extern int net_get_device_conf_req(int net_phone, device_id_t device_id, measured_string_ref * configuration, size_t count, char ** data);
    6968
    7069/** Returns the global configuration.
    … …  
    8079 *  @returns Other error codes as defined for the generic_translate_req() function.
    8180 */
    82 int net_get_conf_req(int net_phone, measured_string_ref * configuration, size_t count, char ** data);
     81extern int net_get_conf_req(int net_phone, measured_string_ref * configuration, size_t count, char ** data);
    8382
    8483/** Frees the received settings.
    … …  
    8887 *  @see net_get_conf_req()
    8988 */
    90 void net_free_settings(measured_string_ref settings, char * data);
     89extern void net_free_settings(measured_string_ref settings, char * data);
    9190
    9291/** Connects to the networking module.
    … …  
    9594 *  @returns 0 if called by the bundle module.
    9695 */
    97 int net_connect_module(services_t service);
     96extern int net_connect_module(services_t service);
    9897
    9998/*@}*/

  • uspace/lib/net/include/net_net_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../messages.h"
     43#include <net_messages.h>
    4444
    4545/** Networking subsystem central module messages.

  • uspace/lib/net/include/netif.h

    r7d6fe4db r849ed54  
    4545#include <ipc/ipc.h>
    4646
    47 #include "../err.h"
    48 
    49 #include "../include/device.h"
    50 
    51 #include "../structures/packet/packet.h"
     47#include <net_err.h>
     48#include <net_device.h>
     49#include <packet/packet.h>
    5250
    5351/** Network interface module skeleton global data.
    … …  
    102100};
    103101
     102extern netif_globals_t netif_globals;
     103
    104104/**     Finds the device specific data.
    105105 *  @param[in] device_id The device identifier.
    … …  
    109109 *  @returns EPERM if the device is not initialized.
    110110 */
    111 int find_device(device_id_t device_id, device_ref * device);
     111extern int find_device(device_id_t device_id, device_ref * device);
    112112
    113113/** Clears the usage statistics.
    114114 *  @param[in] stats The usage statistics.
    115115 */
    116 void null_device_stats(device_stats_ref stats);
     116extern void null_device_stats(device_stats_ref stats);
    117117
    118118// prepared for future optimalizations
    … …  
    120120 *  @param[in] packet_id The packet identifier.
    121121 */
    122 void netif_pq_release(packet_id_t packet_id);
     122extern void netif_pq_release(packet_id_t packet_id);
    123123
    124124/** Allocates new packet to handle the given content size.
    … …  
    127127 *  @returns NULL if there is an error.
    128128 */
    129 packet_t netif_packet_get_1(size_t content);
     129extern packet_t netif_packet_get_1(size_t content);
    130130
    131131/** Processes the netif module messages.
    … …  
    140140 *  @see IS_NET_NETIF_MESSAGE()
    141141 */
    142 int netif_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     142extern int netif_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
    143143
    144144/** Initializes the netif module.
    145145 *  The function has to be defined in each module.
    146  *  @param[in] client_connection The client connection functio to be registered.
     146 *  @param[in] net_client_connection The client connection functio to be registered.
    147147 *  @returns EOK on success.
    148148 *  @returns Other error codes as defined for each specific module message function.
    149149 */
    150 int netif_init_module(async_client_conn_t client_connection);
     150extern int netif_init_module(async_client_conn_t client_connection);
    151151
    152152/** Starts and maintains the netif module until terminated.
    153153 *  @returns EOK after the module is terminated.
    154154 */
    155 int netif_run_module(void);
     155extern int netif_run_module(void);
    156156
    157157#endif

  • uspace/lib/net/include/netif_interface.h

    r7d6fe4db r849ed54  
    4343#include <ipc/services.h>
    4444
    45 #include "../messages.h"
    46 
    47 #include "../structures/measured_strings.h"
    48 #include "../structures/packet/packet.h"
    49 
    50 #include "device.h"
     45#include <net_messages.h>
     46#include <adt/measured_strings.h>
     47#include <packet/packet.h>
     48#include <net_device.h>
    5149
    5250/** @name Network interface module interface
    … …  
    6563 *  @returns Other error codes as defined for the netif_get_addr_message() function.
    6664 */
    67 int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data);
     65extern int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data);
    6866
    6967/** Probes the existence of the device.
    … …  
    7573 *  @returns Other errro codes as defined for the netif_probe_message().
    7674 */
    77 int netif_probe_req(int netif_phone, device_id_t device_id, int irq, int io);
     75extern int netif_probe_req(int netif_phone, device_id_t device_id, int irq, int io);
    7876
    7977/** Sends the packet queue.
    … …  
    8583 *  @returns Other error codes as defined for the generic_send_msg() function.
    8684 */
    87 int netif_send_msg(int netif_phone, device_id_t device_id, packet_t packet, services_t sender);
     85extern int netif_send_msg(int netif_phone, device_id_t device_id, packet_t packet, services_t sender);
    8886
    8987/** Starts the device.
    … …  
    9492 *  @returns Other error codes as defined for the netif_start_message() function.
    9593 */
    96 int netif_start_req(int netif_phone, device_id_t device_id);
     94extern int netif_start_req(int netif_phone, device_id_t device_id);
    9795
    9896/** Stops the device.
    … …  
    103101 *  @returns Other error codes as defined for the netif_stop_message() function.
    104102 */
    105 int netif_stop_req(int netif_phone, device_id_t device_id);
     103extern int netif_stop_req(int netif_phone, device_id_t device_id);
    106104
    107105/** Returns the device usage statistics.
    … …  
    111109 *  @returns EOK on success.
    112110 */
    113 int netif_stats_req(int netif_phone, device_id_t device_id, device_stats_ref stats);
     111extern int netif_stats_req(int netif_phone, device_id_t device_id, device_stats_ref stats);
    114112
    115113/** Creates bidirectional connection with the network interface module and registers the message receiver.
    … …  
    122120 *  @returns Other error codes as defined for the bind_service() function.
    123121 */
    124 int netif_bind_service(services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver);
     122extern int netif_bind_service(services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver);
    125123
    126124/*@}*/

  • uspace/lib/net/include/netif_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../messages.h"
     43#include <net_messages.h>
    4444
    4545/** Network interface common module messages.

  • uspace/lib/net/include/netif_module.h

    r7d6fe4db r849ed54  
    4343#include <ipc/services.h>
    4444
    45 #include "../structures/measured_strings.h"
    46 #include "../structures/packet/packet.h"
    47 
    48 #include "../include/device.h"
     45#include <adt/measured_strings.h>
     46#include <packet/packet.h>
     47#include <net_device.h>
    4948
    5049/** Initializes the specific module.
    5150 */
    52 int netif_initialize(void);
     51extern int netif_initialize(void);
    5352
    5453/** Probes the existence of the device.
    … …  
    6059 *  @returns Other error codes as defined for the specific module message implementation.
    6160 */
    62 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io);
     61extern int netif_probe_message(device_id_t device_id, int irq, uintptr_t io);
    6362
    6463/** Sends the packet queue.
    … …  
    7170 *  @returns Other error codes as defined for the specific module message implementation.
    7271 */
    73 int netif_send_message(device_id_t device_id, packet_t packet, services_t sender);
     72extern int netif_send_message(device_id_t device_id, packet_t packet, services_t sender);
    7473
    7574/** Starts the device.
    … …  
    7978 *  @returns Other error codes as defined for the specific module message implementation.
    8079 */
    81 int netif_start_message(device_ref device);
     80extern int netif_start_message(device_ref device);
    8281
    8382/** Stops the device.
    … …  
    8786 *  @returns Other error codes as defined for the specific module message implementation.
    8887 */
    89 int netif_stop_message(device_ref device);
     88extern int netif_stop_message(device_ref device);
    9089
    9190/** Returns the device local hardware address.
    … …  
    9897 *  @returns Other error codes as defined for the specific module message implementation.
    9998 */
    100 int netif_get_addr_message(device_id_t device_id, measured_string_ref address);
     99extern int netif_get_addr_message(device_id_t device_id, measured_string_ref address);
    101100
    102101/** Processes the netif driver specific message.
    … …  
    110109 *  @returns Other error codes as defined for the specific module message implementation.
    111110 */
    112 int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     111extern int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
    113112
    114113/** Returns the device usage statistics.
    … …  
    119118 *  @returns Other error codes as defined for the specific module message implementation.
    120119 */
    121 int netif_get_device_stats(device_id_t device_id, device_stats_ref stats);
     120extern int netif_get_device_stats(device_id_t device_id, device_stats_ref stats);
    122121
    123122#endif

  • uspace/lib/net/include/nil_interface.h

    r7d6fe4db r849ed54  
    4747#include <ipc/ipc.h>
    4848
    49 #include "../messages.h"
    50 
    51 #include "../structures/measured_strings.h"
    52 #include "../structures/packet/packet.h"
    53 
    54 #include "../nil/nil_messages.h"
    55 
    56 #include "device.h"
     49#include <net_messages.h>
     50#include <adt/measured_strings.h>
     51#include <packet/packet.h>
     52#include <nil_messages.h>
     53#include <net_device.h>
    5754
    5855/** @name Network interface layer module interface
    … …  
    129126 *  @returns Other error codes as defined for each specific module device state function.
    130127 */
    131 int nil_device_state_msg(int nil_phone, device_id_t device_id, int state);
     128extern int nil_device_state_msg(int nil_phone, device_id_t device_id, int state);
    132129
    133130/** Passes the packet queue to the network interface layer.
    … …  
    140137 *  @returns Other error codes as defined for each specific module received function.
    141138 */
    142 int nil_received_msg(int nil_phone, device_id_t device_id, packet_t packet, services_t target);
     139extern int nil_received_msg(int nil_phone, device_id_t device_id, packet_t packet, services_t target);
    143140
    144141/** Creates bidirectional connection with the network interface layer module and registers the message receiver.

  • uspace/lib/net/include/nil_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../messages.h"
     43#include <net_messages.h>
    4444
    4545/**  Network interface layer module messages.

  • uspace/lib/net/include/nil_module.h

    r7d6fe4db r849ed54  
    3636 */
    3737
    38 #ifndef __NET_ETH_MODULE_H__
    39 #define __NET_ETH_MODULE_H__
     38#ifndef __NET_NIL_MODULE_H__
     39#define __NET_NIL_MODULE_H__
    4040
    4141#include <ipc/ipc.h>
    … …  
    4747 *  @returns Other error codes as defined for each specific module initialize function.
    4848 */
    49 int nil_initialize(int net_phone);
     49extern int nil_initialize(int net_phone);
    5050
    5151/** Message processing function.
    … …  
    6060 *  @see IS_NET_NIL_MESSAGE()
    6161 */
    62 int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     62extern int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
    6363
    6464#endif

  • uspace/lib/net/include/protocol_map.h

    r7d6fe4db r849ed54  
    4040#include <ipc/services.h>
    4141
    42 #include "ethernet_lsap.h"
    43 #include "ethernet_protocols.h"
    44 #include "hardware.h"
     42#include <ethernet_lsap.h>
     43#include <ethernet_protocols.h>
     44#include <net_hardware.h>
    4545
    4646/** Maps the internetwork layer service to the network interface layer type.

  • uspace/lib/net/include/tl_common.h

    r7d6fe4db r849ed54  
    3838#define __NET_TL_COMMON_H__
    3939
    40 #include "../structures/packet/packet.h"
    41 
    42 #include "../include/device.h"
    43 #include "../include/inet.h"
    44 #include "../include/socket_codes.h"
     40#include <packet/packet.h>
     41#include <net_device.h>
     42#include <inet.h>
     43#include <socket_codes.h>
    4544
    4645/** Device packet dimensions.
    … …  
    5958 *  @returns EAFNOSUPPORT if the address family is not supported.
    6059 */
    61 int tl_get_address_port(const struct sockaddr * addr, int addrlen, uint16_t * port);
     60extern int tl_get_address_port(const struct sockaddr * addr, int addrlen, uint16_t * port);
    6261
    6362/** Gets IP packet dimensions.
    … …  
    7473 *  @returns Other codes as defined for the ip_packet_size_req() function.
    7574 */
    76 int tl_get_ip_packet_dimension(int ip_phone, packet_dimensions_ref packet_dimensions, device_id_t device_id, packet_dimension_ref * packet_dimension);
     75extern int tl_get_ip_packet_dimension(int ip_phone, packet_dimensions_ref packet_dimensions, device_id_t device_id, packet_dimension_ref * packet_dimension);
    7776
    7877/** Updates IP device packet dimensions cache.
    … …  
    8382 *  @returns ENOENT if the packet dimension is not cached.
    8483 */
    85 int tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions, device_id_t device_id, size_t content);
     84extern int tl_update_ip_packet_dimension(packet_dimensions_ref packet_dimensions, device_id_t device_id, size_t content);
    8685
    8786/** Sets the address port.
    … …  
    9493 *  @returns EAFNOSUPPORT if the address family is not supported.
    9594 */
    96 int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port);
     95extern int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port);
    9796
    9897/** Prepares the packet for ICMP error notification.
    … …  
    106105 *  @returns ENOENT if no packet may be sent.
    107106 */
    108 int tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet, services_t error);
     107extern int tl_prepare_icmp_packet(int packet_phone, int icmp_phone, packet_t packet, services_t error);
    109108
    110109/** Receives data from the socket into a packet.
    … …  
    120119 *  @returns Other error codes as defined for the async_data_read_finalize() function.
    121120 */
    122 int tl_socket_read_packet_data(int packet_phone, packet_ref packet, size_t prefix, const packet_dimension_ref dimension, const struct sockaddr * addr, socklen_t addrlen);
     121extern int tl_socket_read_packet_data(int packet_phone, packet_ref packet, size_t prefix, const packet_dimension_ref dimension, const struct sockaddr * addr, socklen_t addrlen);
    123122
    124123#endif

  • uspace/lib/net/include/tl_interface.h

    r7d6fe4db r849ed54  
    3939
    4040#include <async.h>
    41 
    4241#include <ipc/services.h>
    4342
    44 #include "../messages.h"
    45 
    46 #include "../include/device.h"
    47 
    48 #include "../structures/packet/packet.h"
    49 #include "../structures/packet/packet_client.h"
    50 
    51 #include "../tl/tl_messages.h"
     43#include <net_messages.h>
     44#include <net_device.h>
     45#include <packet/packet.h>
     46#include <packet/packet_client.h>
     47#include <tl_messages.h>
    5248
    5349/** @name Transport layer module interface

  • uspace/lib/net/include/tl_messages.h

    r7d6fe4db r849ed54  
    4141#include <ipc/ipc.h>
    4242
    43 #include "../messages.h"
     43#include <net_messages.h>
    4444
    4545/** Transport layer modules messages.

  • uspace/lib/net/netif/netif.c

    r7d6fe4db r849ed54  
    4444#include <ipc/services.h>
    4545
    46 #include "../err.h"
    47 #include "../messages.h"
    48 #include "../modules.h"
    49 
    50 #include "../structures/packet/packet.h"
    51 #include "../structures/packet/packet_client.h"
    52 #include "../structures/measured_strings.h"
    53 
    54 #include "../include/device.h"
    55 #include "../include/netif_interface.h"
    56 #include "../include/nil_interface.h"
    57 
    58 #include "netif.h"
    59 #include "netif_messages.h"
    60 #include "netif_module.h"
    61 
    62 /** Network interface module global data.
    63  */
    64 extern netif_globals_t netif_globals;
     46#include <net_err.h>
     47#include <net_messages.h>
     48#include <net_modules.h>
     49#include <packet/packet.h>
     50#include <packet/packet_client.h>
     51#include <adt/measured_strings.h>
     52#include <net_device.h>
     53#include <netif_interface.h>
     54#include <nil_interface.h>
     55#include <netif.h>
     56#include <netif_messages.h>
     57#include <netif_module.h>
    6558
    6659DEVICE_MAP_IMPLEMENT(device_map, device_t)
    6760
    68 /** @name Message processing functions
    69  */
    70 /*@{*/
     61/** Network interface global data.
     62 */
     63netif_globals_t netif_globals;
     64
     65int netif_probe_req(int netif_phone, device_id_t device_id, int irq, int io){
     66        int result;
     67
     68        fibril_rwlock_write_lock(&netif_globals.lock);
     69        result = netif_probe_message(device_id, irq, io);
     70        fibril_rwlock_write_unlock(&netif_globals.lock);
     71        return result;
     72}
     73
     74int netif_send_msg(int netif_phone, device_id_t device_id, packet_t packet, services_t sender){
     75        int result;
     76
     77        fibril_rwlock_write_lock(&netif_globals.lock);
     78        result = netif_send_message(device_id, packet, sender);
     79        fibril_rwlock_write_unlock(&netif_globals.lock);
     80        return result;
     81}
     82
     83int netif_start_req(int netif_phone, device_id_t device_id){
     84        ERROR_DECLARE;
     85
     86        device_ref device;
     87        int result;
     88        int phone;
     89
     90        fibril_rwlock_write_lock(&netif_globals.lock);
     91        if(ERROR_OCCURRED(find_device(device_id, &device))){
     92                fibril_rwlock_write_unlock(&netif_globals.lock);
     93                return ERROR_CODE;
     94        }
     95        result = netif_start_message(device);
     96        if(result > NETIF_NULL){
     97                phone = device->nil_phone;
     98                fibril_rwlock_write_unlock(&netif_globals.lock);
     99                nil_device_state_msg(phone, device_id, result);
     100                return EOK;
     101        }else{
     102                fibril_rwlock_write_unlock(&netif_globals.lock);
     103        }
     104        return result;
     105}
     106
     107int netif_stop_req(int netif_phone, device_id_t device_id){
     108        ERROR_DECLARE;
     109
     110        device_ref device;
     111        int result;
     112        int phone;
     113
     114        fibril_rwlock_write_lock(&netif_globals.lock);
     115        if(ERROR_OCCURRED(find_device(device_id, &device))){
     116                fibril_rwlock_write_unlock(&netif_globals.lock);
     117                return ERROR_CODE;
     118        }
     119        result = netif_stop_message(device);
     120        if(result > NETIF_NULL){
     121                phone = device->nil_phone;
     122                fibril_rwlock_write_unlock(&netif_globals.lock);
     123                nil_device_state_msg(phone, device_id, result);
     124                return EOK;
     125        }else{
     126                fibril_rwlock_write_unlock(&netif_globals.lock);
     127        }
     128        return result;
     129}
     130
     131int netif_stats_req(int netif_phone, device_id_t device_id, device_stats_ref stats){
     132        int res;
     133
     134        fibril_rwlock_read_lock(&netif_globals.lock);
     135        res = netif_get_device_stats(device_id, stats);
     136        fibril_rwlock_read_unlock(&netif_globals.lock);
     137        return res;
     138}
     139
     140int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data){
     141        ERROR_DECLARE;
     142
     143        measured_string_t translation;
     144
     145        if(!(address && data)){
     146                return EBADMEM;
     147        }
     148        fibril_rwlock_read_lock(&netif_globals.lock);
     149        if(! ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))){
     150                *address = measured_string_copy(&translation);
     151                ERROR_CODE = (*address) ? EOK : ENOMEM;
     152        }
     153        fibril_rwlock_read_unlock(&netif_globals.lock);
     154        *data = (** address).value;
     155        return ERROR_CODE;
     156}
     157
     158int netif_bind_service(services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver){
     159        return EOK;
     160}
     161
     162int find_device(device_id_t device_id, device_ref * device){
     163        if(! device){
     164                return EBADMEM;
     165        }
     166        *device = device_map_find(&netif_globals.device_map, device_id);
     167        if(! * device){
     168                return ENOENT;
     169        }
     170        if((** device).state == NETIF_NULL) return EPERM;
     171        return EOK;
     172}
     173
     174void null_device_stats(device_stats_ref stats){
     175        bzero(stats, sizeof(device_stats_t));
     176}
    71177
    72178/** Registers the device notification receiver, the network interface layer module.
    … …  
    77183 *  @returns ELIMIT if there is another module registered.
    78184 */
    79 int register_message(device_id_t device_id, int phone);
    80 
    81 /*@}*/
    82 
    83 int netif_probe_req(int netif_phone, device_id_t device_id, int irq, int io){
    84         int result;
    85 
    86         fibril_rwlock_write_lock(&netif_globals.lock);
    87         result = netif_probe_message(device_id, irq, io);
    88         fibril_rwlock_write_unlock(&netif_globals.lock);
    89         return result;
    90 }
    91 
    92 int netif_send_msg(int netif_phone, device_id_t device_id, packet_t packet, services_t sender){
    93         int result;
    94 
    95         fibril_rwlock_write_lock(&netif_globals.lock);
    96         result = netif_send_message(device_id, packet, sender);
    97         fibril_rwlock_write_unlock(&netif_globals.lock);
    98         return result;
    99 }
    100 
    101 int netif_start_req(int netif_phone, device_id_t device_id){
    102         ERROR_DECLARE;
    103 
    104         device_ref device;
    105         int result;
    106         int phone;
    107 
    108         fibril_rwlock_write_lock(&netif_globals.lock);
    109         if(ERROR_OCCURRED(find_device(device_id, &device))){
    110                 fibril_rwlock_write_unlock(&netif_globals.lock);
    111                 return ERROR_CODE;
    112         }
    113         result = netif_start_message(device);
    114         if(result > NETIF_NULL){
    115                 phone = device->nil_phone;
    116                 fibril_rwlock_write_unlock(&netif_globals.lock);
    117                 nil_device_state_msg(phone, device_id, result);
    118                 return EOK;
    119         }else{
    120                 fibril_rwlock_write_unlock(&netif_globals.lock);
    121         }
    122         return result;
    123 }
    124 
    125 int netif_stop_req(int netif_phone, device_id_t device_id){
    126         ERROR_DECLARE;
    127 
    128         device_ref device;
    129         int result;
    130         int phone;
    131 
    132         fibril_rwlock_write_lock(&netif_globals.lock);
    133         if(ERROR_OCCURRED(find_device(device_id, &device))){
    134                 fibril_rwlock_write_unlock(&netif_globals.lock);
    135                 return ERROR_CODE;
    136         }
    137         result = netif_stop_message(device);
    138         if(result > NETIF_NULL){
    139                 phone = device->nil_phone;
    140                 fibril_rwlock_write_unlock(&netif_globals.lock);
    141                 nil_device_state_msg(phone, device_id, result);
    142                 return EOK;
    143         }else{
    144                 fibril_rwlock_write_unlock(&netif_globals.lock);
    145         }
    146         return result;
    147 }
    148 
    149 int netif_stats_req(int netif_phone, device_id_t device_id, device_stats_ref stats){
    150         int res;
    151 
    152         fibril_rwlock_read_lock(&netif_globals.lock);
    153         res = netif_get_device_stats(device_id, stats);
    154         fibril_rwlock_read_unlock(&netif_globals.lock);
    155         return res;
    156 }
    157 
    158 int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data){
    159         ERROR_DECLARE;
    160 
    161         measured_string_t translation;
    162 
    163         if(!(address && data)){
    164                 return EBADMEM;
    165         }
    166         fibril_rwlock_read_lock(&netif_globals.lock);
    167         if(! ERROR_OCCURRED(netif_get_addr_message(device_id, &translation))){
    168                 *address = measured_string_copy(&translation);
    169                 ERROR_CODE = (*address) ? EOK : ENOMEM;
    170         }
    171         fibril_rwlock_read_unlock(&netif_globals.lock);
    172         *data = (** address).value;
    173         return ERROR_CODE;
    174 }
    175 
    176 int netif_bind_service(services_t service, device_id_t device_id, services_t me, async_client_conn_t receiver){
    177         return EOK;
    178 }
    179 
    180 int find_device(device_id_t device_id, device_ref * device){
    181         if(! device){
    182                 return EBADMEM;
    183         }
    184         *device = device_map_find(&netif_globals.device_map, device_id);
    185         if(! * device){
    186                 return ENOENT;
    187         }
    188         if((** device).state == NETIF_NULL) return EPERM;
    189         return EOK;
    190 }
    191 
    192 void null_device_stats(device_stats_ref stats){
    193         bzero(stats, sizeof(device_stats_t));
    194 }
    195 
    196 int register_message(device_id_t device_id, int phone){
     185static int register_message(device_id_t device_id, int phone){
    197186        ERROR_DECLARE;
    198187

  • uspace/lib/net/netif/netif_nil_bundle.c

    r7d6fe4db r849ed54  
    3737
    3838#include <async.h>
    39 
    4039#include <ipc/ipc.h>
    4140
    42 #include "../messages.h"
    43 
    44 #include "../structures/packet/packet.h"
    45 
    46 #include "../nil/nil_module.h"
    47 
    48 #include "netif.h"
    49 
    50 /** Network interface module global data.
    51  */
    52 extern netif_globals_t netif_globals;
     41#include <net_messages.h>
     42#include <packet/packet.h>
     43#include <nil_module.h>
     44#include <netif_nil_bundle.h>
     45#include <netif.h>
    5346
    5447/** Distributes the messages between the module parts.
    … …  
    6154 *  @returns Other error codes as defined for each specific module message function.
    6255 */
    63 int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     56int netif_nil_module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     57        if(IS_NET_NIL_MESSAGE(call) || (IPC_GET_METHOD(*call) == IPC_M_CONNECT_TO_ME)){
     58                return nil_message(callid, call, answer, answer_count);
     59        }else{
     60                return netif_message(callid, call, answer, answer_count);
     61        }
     62}
    6463
    6564/** Starts the bundle network interface module.
    … …  
    6968 *  @returns Other error codes as defined for each specific module message function.
    7069 */
    71 int module_start(async_client_conn_t client_connection);
    72 
    73 int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    74         if(IS_NET_NIL_MESSAGE(call) || (IPC_GET_METHOD(*call) == IPC_M_CONNECT_TO_ME)){
    75                 return nil_message(callid, call, answer, answer_count);
    76         }else{
    77                 return netif_message(callid, call, answer, answer_count);
    78         }
    79 }
    80 
    81 int module_start(async_client_conn_t client_connection){
     70int netif_nil_module_start(async_client_conn_t client_connection){
    8271        ERROR_DECLARE;
    8372

  • uspace/lib/net/netif/netif_standalone.c

    r7d6fe4db r849ed54  
    3636
    3737#include <async.h>
    38 
    3938#include <ipc/ipc.h>
    4039
    41 #include "netif.h"
     40#include <netif.h>
     41#include <netif_standalone.h>
    4242
    4343/** Delegates the messages to the netif_message() function.
    … …  
    5050 *  @returns Other error codes as defined for each specific module message function.
    5151 */
    52 int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     52int netif_module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     53        return netif_message(callid, call, answer, answer_count);
     54}
    5355
    5456/** Starts the network interface module.
    … …  
    5860 *  @returns Other error codes as defined for each specific module message function.
    5961 */
    60 int module_start(async_client_conn_t client_connection);
    61 
    62 int module_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    63         return netif_message(callid, call, answer, answer_count);
    64 }
    65 
    66 int module_start(async_client_conn_t client_connection){
     62int netif_module_start(async_client_conn_t client_connection){
    6763        ERROR_DECLARE;
    6864

  • uspace/lib/net/nil/nil_remote.c

    r7d6fe4db r849ed54  
    3636 */
    3737
    38 #include "../messages.h"
    39 
    40 #include "../include/device.h"
    41 #include "../include/nil_interface.h"
    42 
    43 #include "../structures/packet/packet.h"
    44 #include "../structures/packet/packet_client.h"
    45 
    46 #include "nil_messages.h"
     38#include <net_messages.h>
     39#include <net_device.h>
     40#include <nil_interface.h>
     41#include <packet/packet.h>
     42#include <packet/packet_client.h>
     43#include <nil_messages.h>
    4744
    4845int nil_device_state_msg(int nil_phone, device_id_t device_id, int state){

  • uspace/lib/net/tl/icmp_client.c

    r7d6fe4db r849ed54  
    3636 */
    3737
    38 #include <errno.h>
    39 
    4038#ifdef CONFIG_DEBUG
    4139        #include <stdio.h>
    4240#endif
    4341
     42#include <errno.h>
    4443#include <sys/types.h>
    4544
    46 #include "../../include/icmp_codes.h"
    47 #include "../../include/icmp_client.h"
    48 
    49 #include "../../structures/packet/packet.h"
    50 #include "../../structures/packet/packet_client.h"
    51 
    52 #include "icmp_header.h"
     45#include <icmp_codes.h>
     46#include <icmp_client.h>
     47#include <packet/packet.h>
     48#include <packet/packet_client.h>
     49#include <icmp_header.h>
    5350
    5451int icmp_client_process_packet(packet_t packet, icmp_type_t * type, icmp_code_t * code, icmp_param_t * pointer, icmp_param_t * mtu){

  • uspace/lib/net/tl/icmp_remote.c

    r7d6fe4db r849ed54  
    3838#include <async.h>
    3939#include <errno.h>
    40 
    4140#include <ipc/ipc.h>
    4241#include <ipc/services.h>
    43 
    4442#include <sys/types.h>
    4543
    46 #include "../../messages.h"
    47 #include "../../modules.h"
    48 
    49 #include "../../include/icmp_interface.h"
    50 
    51 #include "../../structures/packet/packet_client.h"
    52 
    53 #include "icmp_messages.h"
     44#include <net_messages.h>
     45#include <net_modules.h>
     46#include <icmp_interface.h>
     47#include <packet/packet_client.h>
     48#include <icmp_messages.h>
    5449
    5550int icmp_destination_unreachable_msg(int icmp_phone, icmp_code_t code, icmp_param_t mtu, packet_t packet){

  • uspace/lib/net/tl/tl_common.c

    r7d6fe4db r849ed54  
    3939#include <ipc/services.h>
    4040
    41 #include "../err.h"
    42 
    43 #include "../structures/packet/packet.h"
    44 #include "../structures/packet/packet_client.h"
    45 
    46 #include "../include/device.h"
    47 #include "../include/icmp_interface.h"
    48 #include "../include/in.h"
    49 #include "../include/in6.h"
    50 #include "../include/inet.h"
    51 #include "../include/ip_interface.h"
    52 #include "../include/socket_codes.h"
    53 #include "../include/socket_errno.h"
    54 
    55 #include "tl_common.h"
     41#include <net_err.h>
     42#include <packet/packet.h>
     43#include <packet/packet_client.h>
     44#include <net_device.h>
     45#include <icmp_interface.h>
     46#include <in.h>
     47#include <in6.h>
     48#include <inet.h>
     49#include <ip_interface.h>
     50#include <socket_codes.h>
     51#include <socket_errno.h>
     52#include <tl_common.h>
    5653
    5754DEVICE_MAP_IMPLEMENT(packet_dimensions, packet_dimension_t);

  • uspace/lib/netif/generic/netif_remote.c

    r7d6fe4db r849ed54  
    3838#include <ipc/services.h>
    3939
    40 #include "../modules.h"
    41 
    42 #include "../structures/measured_strings.h"
    43 #include "../structures/packet/packet.h"
    44 #include "../structures/packet/packet_client.h"
    45 
    46 #include "../include/device.h"
    47 #include "../include/netif_interface.h"
    48 
    49 #include "netif_messages.h"
     40#include <net_modules.h>
     41#include <adt/measured_strings.h>
     42#include <packet/packet.h>
     43#include <packet/packet_client.h>
     44#include <net_device.h>
     45#include <netif_interface.h>
     46#include <netif_messages.h>
    5047
    5148int netif_get_addr_req(int netif_phone, device_id_t device_id, measured_string_ref * address, char ** data){

  • uspace/lib/socket/Makefile

    r7d6fe4db r849ed54  
    2828#
    2929
    30 NET_BASE = ../..
    31 USPACE_PREFIX = ../../../..
    32 LIBS = $(NET_BASE)/socket/libsocket.a
    33 BINARY = ping
     30USPACE_PREFIX = ../..
     31EXTRA_CFLAGS = -Iinclude
     32LIBRARY = libsocket
    3433
    3534SOURCES = \
    36         ping.c \
    37         $(NET_BASE)/app/parse.c \
    38         $(NET_BASE)/app/print_error.c \
    39         $(NET_BASE)/inet.c \
    40         $(NET_BASE)/modules.c \
    41         $(NET_BASE)/tl/icmp/icmp_api.c \
    42         $(NET_BASE)/tl/icmp/icmp_common.c
     35        generic/socket_client.c \
     36        generic/socket_core.c \
     37        generic/inet.c \
     38        generic/net_modules.c \
     39        generic/icmp_common.c \
     40        generic/icmp_api.c \
     41        packet/packet.c \
     42        packet/packet_client.c \
     43        packet/packet_server.c \
     44        adt/dynamic_fifo.c \
     45        adt/measured_strings.c \
     46        adt/char_map.c
    4347
    4448include $(USPACE_PREFIX)/Makefile.common

  • uspace/lib/socket/adt/char_map.c

    r7d6fe4db r849ed54  
    4141#include <unistd.h>
    4242
    43 #include "char_map.h"
     43#include <adt/char_map.h>
    4444
    4545/** Internal magic value for a&nbsp;consistency check.

  • uspace/lib/socket/adt/dynamic_fifo.c

    r7d6fe4db r849ed54  
    3939#include <mem.h>
    4040
    41 #include "dynamic_fifo.h"
     41#include <adt/dynamic_fifo.h>
    4242
    4343/** Internal magic value for a&nbsp;consistency check.
    … …  
    5757 *  @returns FALSE otherwise.
    5858 */
    59 int dyn_fifo_is_valid(dyn_fifo_ref fifo);
    60 
    61 int dyn_fifo_is_valid(dyn_fifo_ref fifo){
     59static int dyn_fifo_is_valid(dyn_fifo_ref fifo){
    6260        return fifo && (fifo->magic_value == DYN_FIFO_MAGIC_VALUE);
    6361}

  • uspace/lib/socket/adt/measured_strings.c

    r7d6fe4db r849ed54  
    4343#include <ipc/ipc.h>
    4444
    45 #include "../err.h"
    46 #include "../modules.h"
    47 
    48 #include "measured_strings.h"
    49 
    50 /** Computes the lengths of the measured strings in the given array.
    51  *  @param[in] strings The measured strings array to be processed.
    52  *  @param[in] count The measured strings array size.
    53  *  @returns The computed sizes array.
    54  *  @returns NULL if there is not enough memory left.
    55  */
    56 size_t * prepare_lengths(const measured_string_ref strings, size_t count);
     45#include <net_err.h>
     46#include <net_modules.h>
     47#include <adt/measured_strings.h>
    5748
    5849measured_string_ref measured_string_create_bulk(const char * string, size_t length){
    … …  
    157148}
    158149
     150/** Computes the lengths of the measured strings in the given array.
     151 *  @param[in] strings The measured strings array to be processed.
     152 *  @param[in] count The measured strings array size.
     153 *  @returns The computed sizes array.
     154 *  @returns NULL if there is not enough memory left.
     155 */
     156static size_t * prepare_lengths(const measured_string_ref strings, size_t count){
     157        size_t * lengths;
     158        size_t index;
     159        size_t length;
     160
     161        lengths = (size_t *) malloc(sizeof(size_t) * (count + 1));
     162        if(! lengths){
     163                return NULL;
     164        }
     165        length = 0;
     166        for(index = 0; index < count; ++ index){
     167                lengths[index] = strings[index].length;
     168                length += lengths[index] + 1;
     169        }
     170        lengths[count] = length;
     171        return lengths;
     172}
     173
    159174int measured_strings_reply(const measured_string_ref strings, size_t count){
    160175        ERROR_DECLARE;
    … …  
    265280}
    266281
    267 size_t * prepare_lengths(const measured_string_ref strings, size_t count){
    268         size_t * lengths;
    269         size_t index;
    270         size_t length;
    271 
    272         lengths = (size_t *) malloc(sizeof(size_t) * (count + 1));
    273         if(! lengths){
    274                 return NULL;
    275         }
    276         length = 0;
    277         for(index = 0; index < count; ++ index){
    278                 lengths[index] = strings[index].length;
    279                 length += lengths[index] + 1;
    280         }
    281         lengths[count] = length;
    282         return lengths;
    283 }
    284 
    285282/** @}
    286283 */

  • uspace/lib/socket/generic/icmp_api.c

    r7d6fe4db r849ed54  
    4343#include <sys/types.h>
    4444
    45 #include "../../modules.h"
    46 
    47 #include "../../include/icmp_api.h"
    48 #include "../../include/inet.h"
    49 #include "../../include/ip_codes.h"
    50 #include "../../include/socket_codes.h"
    51 
    52 #include "icmp_messages.h"
     45#include <net_modules.h>
     46#include <icmp_api.h>
     47#include <inet.h>
     48#include <ip_codes.h>
     49#include <socket_codes.h>
     50#include <icmp_messages.h>
    5351
    5452int icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen){

  • uspace/lib/socket/generic/icmp_common.c

    r7d6fe4db r849ed54  
    3939#include <ipc/services.h>
    4040
    41 #include "../../modules.h"
    42 
    43 #include "../../include/icmp_common.h"
    44 
    45 #include "icmp_messages.h"
     41#include <net_modules.h>
     42#include <icmp_common.h>
     43#include <icmp_messages.h>
    4644
    4745int icmp_connect_module(services_t service, suseconds_t timeout){

  • uspace/lib/socket/generic/inet.c

    r7d6fe4db r849ed54  
    4040#include <str.h>
    4141
    42 #include "include/in.h"
    43 #include "include/in6.h"
    44 #include "include/inet.h"
    45 #include "include/socket_codes.h"
     42#include <in.h>
     43#include <in6.h>
     44#include <inet.h>
     45#include <socket_codes.h>
    4646
    4747int inet_ntop(uint16_t family, const uint8_t * data, char * address, size_t length){

  • uspace/lib/socket/generic/net_modules.c

    r7d6fe4db r849ed54  
    4343#include <sys/time.h>
    4444
    45 #include "err.h"
    46 #include "modules.h"
     45#include <net_err.h>
     46#include <net_modules.h>
    4747
    4848/** The time between connect requests in microseconds.

  • uspace/lib/socket/generic/socket_client.c

    r7d6fe4db r849ed54  
    4545#include <ipc/services.h>
    4646
    47 #include "../err.h"
    48 #include "../modules.h"
    49 
    50 #include "../include/in.h"
    51 #include "../include/socket.h"
    52 #include "../include/socket_errno.h"
    53 
    54 #include "../structures/dynamic_fifo.h"
    55 #include "../structures/int_map.h"
    56 
    57 #include "socket_messages.h"
     47#include <net_err.h>
     48#include <net_modules.h>
     49#include <in.h>
     50#include <socket.h>
     51#include <socket_errno.h>
     52#include <adt/dynamic_fifo.h>
     53#include <adt/int_map.h>
     54#include <socket_messages.h>
    5855
    5956/** Initial received packet queue size.
    … …  
    191188INT_MAP_IMPLEMENT(sockets, socket_t);
    192189
    193 /** Returns the TCP module phone.
    194  *  Connects to the TCP module if necessary.
    195  *  @returns The TCP module phone.
    196  *  @returns Other error codes as defined for the bind_service_timeout() function.
    197  */
    198 static int socket_get_tcp_phone(void);
    199 
    200 /** Returns the UDP module phone.
    201  *  Connects to the UDP module if necessary.
    202  *  @returns The UDP module phone.
    203  *  @returns Other error codes as defined for the bind_service_timeout() function.
    204  */
    205 static int socket_get_udp_phone(void);
    206 
    207190/** Returns the active sockets.
    208191 *  @returns The active sockets.
    209192 */
    210 static sockets_ref socket_get_sockets(void);
    211 
    212 /** Tries to find a new free socket identifier.
    213  *      @returns The new socket identifier.
    214  *  @returns ELIMIT if there is no socket identifier available.
    215  */
    216 static int socket_generate_new_id(void);
    217 
    218 /** Default thread for new connections.
    219  *  @param[in] iid The initial message identifier.
    220  *  @param[in] icall The initial message call structure.
    221  */
    222 void socket_connection(ipc_callid_t iid, ipc_call_t * icall);
    223 
    224 /** Sends message to the socket parent module with specified data.
    225  *  @param[in] socket_id Socket identifier.
    226  *  @param[in] message The action message.
    227  *  @param[in] arg2 The second message parameter.
    228  *  @param[in] data The data to be sent.
    229  *  @param[in] datalength The data length.
    230  *  @returns EOK on success.
    231  *  @returns ENOTSOCK if the socket is not found.
    232  *  @returns EBADMEM if the data parameter is NULL.
    233  *  @returns NO_DATA if the datalength parameter is zero (0).
    234  *  @returns Other error codes as defined for the spcific message.
    235  */
    236 int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength);
    237 
    238 /** Initializes a new socket specific data.
    239  *  @param[in,out] socket The socket to be initialized.
    240  *  @param[in] socket_id The new socket identifier.
    241  *  @param[in] phone The parent module phone.
    242  *  @param[in] service The parent module service.
    243  */
    244 void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service);
    245 
    246 /** Clears and destroys the socket.
    247  *  @param[in] socket The socket to be destroyed.
    248  */
    249 void socket_destroy(socket_ref socket);
    250 
    251 /** Receives data via the socket.
    252  *  @param[in] message The action message.
    253  *  @param[in] socket_id Socket identifier.
    254  *  @param[out] data The data buffer to be filled.
    255  *  @param[in] datalength The data length.
    256  *  @param[in] flags Various receive flags.
    257  *  @param[out] fromaddr The source address. May be NULL for connected sockets.
    258  *  @param[in,out] addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL.
    259  *  @returns EOK on success.
    260  *  @returns ENOTSOCK if the socket is not found.
    261  *  @returns EBADMEM if the data parameter is NULL.
    262  *  @returns NO_DATA if the datalength or addrlen parameter is zero (0).
    263  *  @returns Other error codes as defined for the spcific message.
    264  */
    265 int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen);
    266 
    267 /** Sends data via the socket to the remote address.
    268  *  Binds the socket to a free port if not already connected/bound.
    269  *  @param[in] message The action message.
    270  *  @param[in] socket_id Socket identifier.
    271  *  @param[in] data The data to be sent.
    272  *  @param[in] datalength The data length.
    273  *  @param[in] flags Various send flags.
    274  *  @param[in] toaddr The destination address. May be NULL for connected sockets.
    275  *  @param[in] addrlen The address length. Used only if toaddr is not NULL.
    276  *  @returns EOK on success.
    277  *  @returns ENOTSOCK if the socket is not found.
    278  *  @returns EBADMEM if the data or toaddr parameter is NULL.
    279  *  @returns NO_DATA if the datalength or the addrlen parameter is zero (0).
    280  *  @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
    281  */
    282 int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen);
    283 
    284 static int socket_get_tcp_phone(void){
    285         if(socket_globals.tcp_phone < 0){
    286                 socket_globals.tcp_phone = bind_service_timeout(SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection, SOCKET_CONNECT_TIMEOUT);
    287         }
    288         return socket_globals.tcp_phone;
    289 }
    290 
    291 static int socket_get_udp_phone(void){
    292         if(socket_globals.udp_phone < 0){
    293                 socket_globals.udp_phone = bind_service_timeout(SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection, SOCKET_CONNECT_TIMEOUT);
    294         }
    295         return socket_globals.udp_phone;
    296 }
    297 
    298193static sockets_ref socket_get_sockets(void){
    299194        if(! socket_globals.sockets){
    … …  
    311206}
    312207
    313 static int socket_generate_new_id(void){
    314         sockets_ref sockets;
    315         int socket_id;
    316         int count;
    317 
    318         sockets = socket_get_sockets();
    319         count = 0;
    320 //      socket_id = socket_globals.last_id;
    321         do{
    322                 if(count < SOCKET_ID_TRIES){
    323                         socket_id = rand() % INT_MAX;
    324                         ++ count;
    325                 }else if(count == SOCKET_ID_TRIES){
    326                         socket_id = 1;
    327                         ++ count;
    328                 // only this branch for last_id
    329                 }else{
    330                         if(socket_id < INT_MAX){
    331                                 ++ socket_id;
    332 /*                      }else if(socket_globals.last_id){
    333 *                               socket_globals.last_id = 0;
    334 *                               socket_id = 1;
    335 */                      }else{
    336                                 return ELIMIT;
    337                         }
    338                 }
    339         }while(sockets_find(sockets, socket_id));
    340 //      last_id = socket_id
    341         return socket_id;
    342 }
    343 
    344 void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service){
    345         socket->socket_id = socket_id;
    346         socket->phone = phone;
    347         socket->service = service;
    348         dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
    349         dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
    350         fibril_mutex_initialize(&socket->receive_lock);
    351         fibril_condvar_initialize(&socket->receive_signal);
    352         fibril_mutex_initialize(&socket->accept_lock);
    353         fibril_condvar_initialize(&socket->accept_signal);
    354         fibril_rwlock_initialize(&socket->sending_lock);
    355 }
    356 
    357 void socket_connection(ipc_callid_t iid, ipc_call_t * icall){
     208/** Default thread for new connections.
     209 *  @param[in] iid The initial message identifier.
     210 *  @param[in] icall The initial message call structure.
     211 */
     212static void socket_connection(ipc_callid_t iid, ipc_call_t * icall){
    358213        ERROR_DECLARE;
    359214
    … …  
    414269}
    415270
     271/** Returns the TCP module phone.
     272 *  Connects to the TCP module if necessary.
     273 *  @returns The TCP module phone.
     274 *  @returns Other error codes as defined for the bind_service_timeout() function.
     275 */
     276static int socket_get_tcp_phone(void){
     277        if(socket_globals.tcp_phone < 0){
     278                socket_globals.tcp_phone = bind_service_timeout(SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection, SOCKET_CONNECT_TIMEOUT);
     279        }
     280        return socket_globals.tcp_phone;
     281}
     282
     283/** Returns the UDP module phone.
     284 *  Connects to the UDP module if necessary.
     285 *  @returns The UDP module phone.
     286 *  @returns Other error codes as defined for the bind_service_timeout() function.
     287 */
     288static int socket_get_udp_phone(void){
     289        if(socket_globals.udp_phone < 0){
     290                socket_globals.udp_phone = bind_service_timeout(SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection, SOCKET_CONNECT_TIMEOUT);
     291        }
     292        return socket_globals.udp_phone;
     293}
     294
     295/** Tries to find a new free socket identifier.
     296 *      @returns The new socket identifier.
     297 *  @returns ELIMIT if there is no socket identifier available.
     298 */
     299static int socket_generate_new_id(void){
     300        sockets_ref sockets;
     301        int socket_id;
     302        int count;
     303
     304        sockets = socket_get_sockets();
     305        count = 0;
     306//      socket_id = socket_globals.last_id;
     307        do{
     308                if(count < SOCKET_ID_TRIES){
     309                        socket_id = rand() % INT_MAX;
     310                        ++ count;
     311                }else if(count == SOCKET_ID_TRIES){
     312                        socket_id = 1;
     313                        ++ count;
     314                // only this branch for last_id
     315                }else{
     316                        if(socket_id < INT_MAX){
     317                                ++ socket_id;
     318/*                      }else if(socket_globals.last_id){
     319*                               socket_globals.last_id = 0;
     320*                               socket_id = 1;
     321*/                      }else{
     322                                return ELIMIT;
     323                        }
     324                }
     325        }while(sockets_find(sockets, socket_id));
     326//      last_id = socket_id
     327        return socket_id;
     328}
     329
     330/** Initializes a new socket specific data.
     331 *  @param[in,out] socket The socket to be initialized.
     332 *  @param[in] socket_id The new socket identifier.
     333 *  @param[in] phone The parent module phone.
     334 *  @param[in] service The parent module service.
     335 */
     336static void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service){
     337        socket->socket_id = socket_id;
     338        socket->phone = phone;
     339        socket->service = service;
     340        dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
     341        dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
     342        fibril_mutex_initialize(&socket->receive_lock);
     343        fibril_condvar_initialize(&socket->receive_signal);
     344        fibril_mutex_initialize(&socket->accept_lock);
     345        fibril_condvar_initialize(&socket->accept_signal);
     346        fibril_rwlock_initialize(&socket->sending_lock);
     347}
     348
    416349int socket(int domain, int type, int protocol){
    417350        ERROR_DECLARE;
    … …  
    503436}
    504437
    505 int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength){
     438/** Sends message to the socket parent module with specified data.
     439 *  @param[in] socket_id Socket identifier.
     440 *  @param[in] message The action message.
     441 *  @param[in] arg2 The second message parameter.
     442 *  @param[in] data The data to be sent.
     443 *  @param[in] datalength The data length.
     444 *  @returns EOK on success.
     445 *  @returns ENOTSOCK if the socket is not found.
     446 *  @returns EBADMEM if the data parameter is NULL.
     447 *  @returns NO_DATA if the datalength parameter is zero (0).
     448 *  @returns Other error codes as defined for the spcific message.
     449 */
     450static int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength){
    506451        socket_ref socket;
    507452        aid_t message_id;
    … …  
    650595}
    651596
     597/** Clears and destroys the socket.
     598 *  @param[in] socket The socket to be destroyed.
     599 */
     600static void socket_destroy(socket_ref socket){
     601        int accepted_id;
     602
     603        // destroy all accepted sockets
     604        while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
     605                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
     606        }
     607        dyn_fifo_destroy(&socket->received);
     608        dyn_fifo_destroy(&socket->accepted);
     609        sockets_exclude(socket_get_sockets(), socket->socket_id);
     610}
     611
    652612int closesocket(int socket_id){
    653613        ERROR_DECLARE;
    … …  
    673633}
    674634
    675 void socket_destroy(socket_ref socket){
    676         int accepted_id;
    677 
    678         // destroy all accepted sockets
    679         while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
    680                 socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    681         }
    682         dyn_fifo_destroy(&socket->received);
    683         dyn_fifo_destroy(&socket->accepted);
    684         sockets_exclude(socket_get_sockets(), socket->socket_id);
    685 }
    686 
    687 int send(int socket_id, void * data, size_t datalength, int flags){
    688         // without the address
    689         return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0);
    690 }
    691 
    692 int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
    693         if(! toaddr){
    694                 return EDESTADDRREQ;
    695         }
    696         if(! addrlen){
    697                 return EDESTADDRREQ;
    698         }
    699         // with the address
    700         return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen);
    701 }
    702 
    703 int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
     635/** Sends data via the socket to the remote address.
     636 *  Binds the socket to a free port if not already connected/bound.
     637 *  @param[in] message The action message.
     638 *  @param[in] socket_id Socket identifier.
     639 *  @param[in] data The data to be sent.
     640 *  @param[in] datalength The data length.
     641 *  @param[in] flags Various send flags.
     642 *  @param[in] toaddr The destination address. May be NULL for connected sockets.
     643 *  @param[in] addrlen The address length. Used only if toaddr is not NULL.
     644 *  @returns EOK on success.
     645 *  @returns ENOTSOCK if the socket is not found.
     646 *  @returns EBADMEM if the data or toaddr parameter is NULL.
     647 *  @returns NO_DATA if the datalength or the addrlen parameter is zero (0).
     648 *  @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
     649 */
     650static int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
    704651        socket_ref socket;
    705652        aid_t message_id;
    … …  
    760707}
    761708
    762 int recv(int socket_id, void * data, size_t datalength, int flags){
     709int send(int socket_id, void * data, size_t datalength, int flags){
    763710        // without the address
    764         return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL);
    765 }
    766 
    767 int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
    768         if(! fromaddr){
    769                 return EBADMEM;
     711        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0);
     712}
     713
     714int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
     715        if(! toaddr){
     716                return EDESTADDRREQ;
    770717        }
    771718        if(! addrlen){
    772                 return NO_DATA;
     719                return EDESTADDRREQ;
    773720        }
    774721        // with the address
    775         return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen);
    776 }
    777 
    778 int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
     722        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen);
     723}
     724
     725/** Receives data via the socket.
     726 *  @param[in] message The action message.
     727 *  @param[in] socket_id Socket identifier.
     728 *  @param[out] data The data buffer to be filled.
     729 *  @param[in] datalength The data length.
     730 *  @param[in] flags Various receive flags.
     731 *  @param[out] fromaddr The source address. May be NULL for connected sockets.
     732 *  @param[in,out] addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL.
     733 *  @returns EOK on success.
     734 *  @returns ENOTSOCK if the socket is not found.
     735 *  @returns EBADMEM if the data parameter is NULL.
     736 *  @returns NO_DATA if the datalength or addrlen parameter is zero (0).
     737 *  @returns Other error codes as defined for the spcific message.
     738 */
     739static int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
    779740        socket_ref socket;
    780741        aid_t message_id;
    … …  
    866827}
    867828
     829int recv(int socket_id, void * data, size_t datalength, int flags){
     830        // without the address
     831        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL);
     832}
     833
     834int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
     835        if(! fromaddr){
     836                return EBADMEM;
     837        }
     838        if(! addrlen){
     839                return NO_DATA;
     840        }
     841        // with the address
     842        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen);
     843}
     844
    868845int getsockopt(int socket_id, int level, int optname, void * value, size_t * optlen){
    869846        socket_ref socket;

  • uspace/lib/socket/generic/socket_core.c

    r7d6fe4db r849ed54  
    3838#include <stdlib.h>
    3939
    40 #include "../err.h"
    41 
    42 #include "../include/in.h"
    43 #include "../include/inet.h"
    44 
    45 #include "../include/socket_codes.h"
    46 #include "../include/socket_errno.h"
    47 
    48 #include "../structures/dynamic_fifo.h"
    49 #include "../structures/int_map.h"
    50 #include "../structures/packet/packet.h"
    51 #include "../structures/packet/packet_client.h"
    52 
    53 #include "../modules.h"
    54 
    55 #include "socket_core.h"
     40#include <net_err.h>
     41#include <in.h>
     42#include <inet.h>
     43#include <socket_codes.h>
     44#include <socket_errno.h>
     45#include <adt/dynamic_fifo.h>
     46#include <adt/int_map.h>
     47#include <packet/packet.h>
     48#include <packet/packet_client.h>
     49#include <net_modules.h>
     50#include <socket_core.h>
    5651
    5752/** Maximum number of random attempts to find a new socket identifier before switching to the sequence.
    … …  
    7065};
    7166
    72 /** Binds the socket to the port.
    73  *  The SOCKET_MAP_KEY_LISTENING key identifier is used.
    74  *  @param[in] global_sockets The global sockets to be updated.
    75  *  @param[in] socket The socket to be added.
    76  *  @param[in] port The port number to be bound to.
    77  *  @returns EOK on success.
    78  *  @returns ENOMEM if there is not enough memory left.
    79  *  @returns Other error codes as defined for the socket_ports_add() function.
    80  */
    81 int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port);
     67INT_MAP_IMPLEMENT(socket_cores, socket_core_t);
     68
     69GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_ref);
     70
     71INT_MAP_IMPLEMENT(socket_ports, socket_port_t);
    8272
    8373/** Destroys the socket.
    … …  
    9080 *  @param[in] socket_release The client release callback function.
    9181 */
    92 void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    93 
    94 /** Adds the socket to a socket port.
    95  *  @param[in,out] socket_port The socket port structure.
    96  *  @param[in] socket The socket to be added.
    97  *  @param[in] key The socket key identifier.
    98  *  @param[in] key_length The socket key length.
    99  *  @returns EOK on success.
    100  *  @returns ENOMEM if there is not enough memory left.
    101  */
    102 int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length);
    103 
    104 /** Tries to find a new free socket identifier.
    105  *  @param[in] local_sockets The local sockets to be searched.
    106  *  @param[in] positive A value indicating whether a positive identifier is requested. A negative identifier is requested if set to false.
    107  *      @returns The new socket identifier.
    108  *  @returns ELIMIT if there is no socket identifier available.
    109  */
    110 static int socket_generate_new_id(socket_cores_ref local_sockets, int positive);
    111 
    112 INT_MAP_IMPLEMENT(socket_cores, socket_core_t);
    113 
    114 GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_ref);
    115 
    116 INT_MAP_IMPLEMENT(socket_ports, socket_port_t);
     82static void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
     83        int packet_id;
     84
     85        // if bound
     86        if(socket->port){
     87                // release the port
     88                socket_port_release(global_sockets, socket);
     89        }
     90        // release all received packets
     91        while((packet_id = dyn_fifo_pop(&socket->received)) >= 0){
     92                pq_release(packet_phone, packet_id);
     93        }
     94        dyn_fifo_destroy(&socket->received);
     95        dyn_fifo_destroy(&socket->accepted);
     96        if(socket_release){
     97                socket_release(socket);
     98        }
     99        socket_cores_exclude(local_sockets, socket->socket_id);
     100}
    117101
    118102void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
    … …  
    135119}
    136120
    137 void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
    138         int packet_id;
    139 
    140         // if bound
    141         if(socket->port){
    142                 // release the port
    143                 socket_port_release(global_sockets, socket);
    144         }
    145         // release all received packets
    146         while((packet_id = dyn_fifo_pop(&socket->received)) >= 0){
    147                 pq_release(packet_phone, packet_id);
    148         }
    149         dyn_fifo_destroy(&socket->received);
    150         dyn_fifo_destroy(&socket->accepted);
    151         if(socket_release){
    152                 socket_release(socket);
    153         }
    154         socket_cores_exclude(local_sockets, socket->socket_id);
     121/** Adds the socket to a socket port.
     122 *  @param[in,out] socket_port The socket port structure.
     123 *  @param[in] socket The socket to be added.
     124 *  @param[in] key The socket key identifier.
     125 *  @param[in] key_length The socket key length.
     126 *  @returns EOK on success.
     127 *  @returns ENOMEM if there is not enough memory left.
     128 */
     129static int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length){
     130        ERROR_DECLARE;
     131
     132        socket_core_ref * socket_ref;
     133
     134        // create a wrapper
     135        socket_ref = malloc(sizeof(*socket_ref));
     136        if(! socket_ref){
     137                return ENOMEM;
     138        }
     139        *socket_ref = socket;
     140        // add the wrapper
     141        if(ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key, key_length, socket_ref))){
     142                free(socket_ref);
     143                return ERROR_CODE;
     144        }
     145        ++ socket_port->count;
     146        socket->key = key;
     147        socket->key_length = key_length;
     148        return EOK;
     149}
     150
     151/** Binds the socket to the port.
     152 *  The SOCKET_MAP_KEY_LISTENING key identifier is used.
     153 *  @param[in] global_sockets The global sockets to be updated.
     154 *  @param[in] socket The socket to be added.
     155 *  @param[in] port The port number to be bound to.
     156 *  @returns EOK on success.
     157 *  @returns ENOMEM if there is not enough memory left.
     158 *  @returns Other error codes as defined for the socket_ports_add() function.
     159 */
     160static int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port){
     161        ERROR_DECLARE;
     162
     163        socket_port_ref socket_port;
     164
     165        // create a wrapper
     166        socket_port = malloc(sizeof(*socket_port));
     167        if(! socket_port){
     168                return ENOMEM;
     169        }
     170        socket_port->count = 0;
     171        if(ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map))
     172                || ERROR_OCCURRED(socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0))){
     173                socket_port_map_destroy(&socket_port->map);
     174                free(socket_port);
     175                return ERROR_CODE;
     176        }
     177        // register the incomming port
     178        ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
     179        if(ERROR_CODE < 0){
     180                socket_port_map_destroy(&socket_port->map);
     181                free(socket_port);
     182                return ERROR_CODE;
     183        }
     184        socket->port = port;
     185        return EOK;
    155186}
    156187
    … …  
    225256}
    226257
    227 int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port){
    228         ERROR_DECLARE;
    229 
    230         socket_port_ref socket_port;
    231 
    232         // create a wrapper
    233         socket_port = malloc(sizeof(*socket_port));
    234         if(! socket_port){
    235                 return ENOMEM;
    236         }
    237         socket_port->count = 0;
    238         if(ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map))
    239                 || ERROR_OCCURRED(socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0))){
    240                 socket_port_map_destroy(&socket_port->map);
    241                 free(socket_port);
    242                 return ERROR_CODE;
    243         }
    244         // register the incomming port
    245         ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
    246         if(ERROR_CODE < 0){
    247                 socket_port_map_destroy(&socket_port->map);
    248                 free(socket_port);
    249                 return ERROR_CODE;
    250         }
    251         socket->port = port;
    252         return EOK;
    253 }
    254 
    255 
     258/** Tries to find a new free socket identifier.
     259 *  @param[in] local_sockets The local sockets to be searched.
     260 *  @param[in] positive A value indicating whether a positive identifier is requested. A negative identifier is requested if set to false.
     261 *      @returns The new socket identifier.
     262 *  @returns ELIMIT if there is no socket identifier available.
     263 */
    256264static int socket_generate_new_id(socket_cores_ref local_sockets, int positive){
    257265        int socket_id;
    … …  
    465473}
    466474
    467 int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length){
    468         ERROR_DECLARE;
    469 
    470         socket_core_ref * socket_ref;
    471 
    472         // create a wrapper
    473         socket_ref = malloc(sizeof(*socket_ref));
    474         if(! socket_ref){
    475                 return ENOMEM;
    476         }
    477         *socket_ref = socket;
    478         // add the wrapper
    479         if(ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key, key_length, socket_ref))){
    480                 free(socket_ref);
    481                 return ERROR_CODE;
    482         }
    483         ++ socket_port->count;
    484         socket->key = key;
    485         socket->key_length = key_length;
    486         return EOK;
    487 }
    488 
    489475/** @}
    490476 */

  • uspace/lib/socket/include/adt/char_map.h

    r7d6fe4db r849ed54  
    8989 *  @returns Other error codes as defined for the char_map_add_item() function.
    9090 */
    91 int char_map_add(char_map_ref map, const char * identifier, size_t length, const int value);
     91extern int char_map_add(char_map_ref map, const char * identifier, size_t length, const int value);
    9292
    9393/** Clears and destroys the map.
    9494 *  @param[in,out] map The character string to integer map.
    9595 */
    96 void char_map_destroy(char_map_ref map);
     96extern void char_map_destroy(char_map_ref map);
    9797
    9898/** Excludes the value assigned to the key from the map.
    … …  
    104104 *  @returns CHAR_MAP_NULL if the key is not assigned a&nbsp;value.
    105105 */
    106 int char_map_exclude(char_map_ref map, const char * identifier, size_t length);
     106extern int char_map_exclude(char_map_ref map, const char * identifier, size_t length);
    107107
    108108/** Returns the value assigned to the key from the map.
    … …  
    113113 *  @returns CHAR_MAP_NULL if the key is not assigned a&nbsp;value.
    114114 */
    115 int char_map_find(const char_map_ref map, const char * identifier, size_t length);
     115extern int char_map_find(const char_map_ref map, const char * identifier, size_t length);
    116116
    117117/** Initializes the map.
    … …  
    121121 *  @returns ENOMEM if there is not enough memory left.
    122122 */
    123 int char_map_initialize(char_map_ref map);
     123extern int char_map_initialize(char_map_ref map);
    124124
    125125/** Adds or updates the value with the key to the map.
    … …  
    135135 *  @returns Other error codes as defined for the char_map_add_item() function.
    136136 */
    137 int char_map_update(char_map_ref map, const char * identifier, size_t length, const int value);
     137extern int char_map_update(char_map_ref map, const char * identifier, size_t length, const int value);
    138138
    139139#endif

  • uspace/lib/socket/include/adt/dynamic_fifo.h

    r7d6fe4db r849ed54  
    7979 *  @returns ENOMEM if there is not enough memory left.
    8080 */
    81 int dyn_fifo_initialize(dyn_fifo_ref fifo, int size);
     81extern int dyn_fifo_initialize(dyn_fifo_ref fifo, int size);
    8282
    8383/** Appends a new item to the queue end.
    … …  
    8989 *  @returns ENOMEM if there is not enough memory left.
    9090 */
    91 int dyn_fifo_push(dyn_fifo_ref fifo, int value, int max_size);
     91extern int dyn_fifo_push(dyn_fifo_ref fifo, int value, int max_size);
    9292
    9393/** Returns and excludes the first item in the queue.
    … …  
    9797 *  @returns ENOENT if the queue is empty.
    9898 */
    99 int dyn_fifo_pop(dyn_fifo_ref fifo);
     99extern int dyn_fifo_pop(dyn_fifo_ref fifo);
    100100
    101101/** Returns and keeps the first item in the queue.
    … …  
    105105 *  @returns ENOENT if the queue is empty.
    106106 */
    107 int dyn_fifo_value(dyn_fifo_ref fifo);
     107extern int dyn_fifo_value(dyn_fifo_ref fifo);
    108108
    109109/** Clears and destroys the queue.
    … …  
    112112 *  @returns EINVAL if the queue is not valid.
    113113 */
    114 int dyn_fifo_destroy(dyn_fifo_ref fifo);
     114extern int dyn_fifo_destroy(dyn_fifo_ref fifo);
    115115
    116116#endif

  • uspace/lib/socket/include/adt/generic_char_map.h

    r7d6fe4db r849ed54  
    4141#include <unistd.h>
    4242
    43 #include "../err.h"
     43#include <net_err.h>
    4444
    45 #include "char_map.h"
    46 #include "generic_field.h"
     45#include <adt/char_map.h>
     46#include <adt/generic_field.h>
    4747
    4848/** Internal magic value for a&nbsp;map consistency check.

  • uspace/lib/socket/include/adt/measured_strings.h

    r7d6fe4db r849ed54  
    7171 *  @returns NULL if there is not enough memory left.
    7272 */
    73 measured_string_ref measured_string_create_bulk(const char * string, size_t length);
     73extern measured_string_ref measured_string_create_bulk(const char * string, size_t length);
    7474
    7575/** Copies the given measured string with separated header and data parts.
    … …  
    7979 *  @returns NULL if there is not enough memory left.
    8080 */
    81 measured_string_ref measured_string_copy(measured_string_ref source);
     81extern measured_string_ref measured_string_copy(measured_string_ref source);
    8282
    8383/** Receives a&nbsp;measured strings array from a&nbsp;calling module.
    … …  
    9595 *  @returns Other error codes as defined for the async_data_write_finalize() function.
    9696 */
    97 int measured_strings_receive(measured_string_ref * strings, char ** data, size_t count);
     97extern int measured_strings_receive(measured_string_ref * strings, char ** data, size_t count);
    9898
    9999/** Replies the given measured strings array to a&nbsp;calling module.
    … …  
    108108 *  @returns Other error codes as defined for the async_data_read_finalize() function.
    109109 */
    110 int measured_strings_reply(const measured_string_ref strings, size_t count);
     110extern int measured_strings_reply(const measured_string_ref strings, size_t count);
    111111
    112112/** Receives a&nbsp;measured strings array from another module.
    … …  
    124124 *  @returns Other error codes as defined for the async_data_read_start() function.
    125125 */
    126 int measured_strings_return(int phone, measured_string_ref * strings, char ** data, size_t count);
     126extern int measured_strings_return(int phone, measured_string_ref * strings, char ** data, size_t count);
    127127
    128128/** Sends the given measured strings array to another module.
    … …  
    136136 *  @returns Other error codes as defined for the async_data_write_start() function.
    137137 */
    138 int measured_strings_send(int phone, const measured_string_ref strings, size_t count);
     138extern int measured_strings_send(int phone, const measured_string_ref strings, size_t count);
    139139
    140140#endif

  • uspace/lib/socket/include/icmp_api.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "device.h"
    43 
    44 #include "../structures/measured_strings.h"
    45 #include "../structures/packet/packet.h"
    46 
    47 #include "inet.h"
    48 #include "ip_codes.h"
    49 #include "socket_codes.h"
    50 
    51 #include "icmp_codes.h"
    52 #include "icmp_common.h"
     42#include <net_device.h>
     43#include <adt/measured_strings.h>
     44#include <packet/packet.h>
     45#include <inet.h>
     46#include <ip_codes.h>
     47#include <socket_codes.h>
     48#include <icmp_codes.h>
     49#include <icmp_common.h>
    5350
    5451/** Miliseconds type definition.
    … …  
    7976 *  @returns EPARTY if there was an internal error.
    8077 */
    81 int icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen);
     78extern int icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment, const struct sockaddr * addr, socklen_t addrlen);
    8279
    8380/*@}*/

  • uspace/lib/socket/include/icmp_common.h

    r7d6fe4db r849ed54  
    5353 *  @returns ETIMEOUT if the connection timeouted.
    5454 */
    55 int icmp_connect_module(services_t service, suseconds_t timeout);
     55extern int icmp_connect_module(services_t service, suseconds_t timeout);
    5656
    5757#endif

  • uspace/lib/socket/include/icmp_messages.h

    r7d6fe4db r849ed54  
    4040
    4141#include <ipc/ipc.h>
    42 
    4342#include <sys/types.h>
    4443
    45 #include "../../include/icmp_codes.h"
    46 
    47 #include "../../messages.h"
     44#include <icmp_codes.h>
     45#include <net_messages.h>
    4846
    4947/** ICMP module messages.

  • uspace/lib/socket/include/in.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "ip_protocols.h"
    43 #include "inet.h"
     42#include <ip_protocols.h>
     43#include <inet.h>
    4444
    4545/** INET string address maximum length.

  • uspace/lib/socket/include/in6.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "ip_protocols.h"
    43 #include "inet.h"
     42#include <ip_protocols.h>
     43#include <inet.h>
    4444
    4545/** INET6 string address maximum length.

  • uspace/lib/socket/include/inet.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "byteorder.h"
     42#include <net_byteorder.h>
    4343
    4444/** Type definition of the socket address.
    … …  
    6262 *  @returns ENOTSUP if the address family is not supported.
    6363 */
    64 int inet_ntop(uint16_t family, const uint8_t * data, char * address, size_t length);
     64extern int inet_ntop(uint16_t family, const uint8_t * data, char * address, size_t length);
    6565
    6666/** Parses the character string into the address.
    … …  
    7474 *  @returns ENOTSUP if the address family is not supported.
    7575 */
    76 int inet_pton(uint16_t family, const char * address, uint8_t * data);
     76extern int inet_pton(uint16_t family, const char * address, uint8_t * data);
    7777
    7878/** Socket address.

  • uspace/lib/socket/include/net_device.h

    r7d6fe4db r849ed54  
    3838#define __NET_DEVICE_ID_TYPE_H__
    3939
    40 #include "../structures/int_map.h"
     40#include <adt/int_map.h>
    4141
    4242/** Device identifier to generic type map declaration.

  • uspace/lib/socket/include/net_messages.h

    r7d6fe4db r849ed54  
    4343#include <ipc/services.h>
    4444
    45 #include "include/device.h"
    46 
    47 #include "structures/measured_strings.h"
    48 #include "structures/packet/packet.h"
     45#include <net_device.h>
     46#include <adt/measured_strings.h>
     47#include <packet/packet.h>
    4948
    5049/** Returns a value indicating whether the value is in the interval.

  • uspace/lib/socket/include/net_modules.h

    r7d6fe4db r849ed54  
    7070 *  @param[in] answer_count The number of answer parameters.
    7171 */
    72 void answer_call(ipc_callid_t callid, int result, ipc_call_t * answer, int answer_count);
     72extern void answer_call(ipc_callid_t callid, int result, ipc_call_t * answer, int answer_count);
    7373
    7474/** Creates bidirectional connection with the needed module service and registers the message receiver.
    … …  
    8181 *  @returns Other error codes as defined for the ipc_connect_to_me() function.
    8282 */
    83 int bind_service(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, async_client_conn_t client_receiver);
     83extern int bind_service(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, async_client_conn_t client_receiver);
    8484
    8585/** Creates bidirectional connection with the needed module service and registers the message receiver.
    … …  
    9494 *  @returns Other error codes as defined for the ipc_connect_to_me() function.
    9595 */
    96 int bind_service_timeout(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout);
     96extern int bind_service_timeout(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout);
    9797
    9898/** Connects to the needed module.
    … …  
    100100 *  @returns The phone of the needed service.
    101101 */
    102 int connect_to_service(services_t need);
     102extern int connect_to_service(services_t need);
    103103
    104104/** Connects to the needed module.
    … …  
    108108 *  @returns ETIMEOUT if the connection timeouted.
    109109 */
    110 int connect_to_service_timeout(services_t need, suseconds_t timeout);
     110extern int connect_to_service_timeout(services_t need, suseconds_t timeout);
    111111
    112112/** Receives data from the other party.
    … …  
    120120 *  @returns Other error codes as defined for the async_data_write_finalize() function.
    121121 */
    122 int data_receive(void ** data, size_t * length);
     122extern int data_receive(void ** data, size_t * length);
    123123
    124124/** Replies the data to the other party.
    … …  
    130130 *  @returns Other error codes as defined for the async_data_read_finalize() function.
    131131 */
    132 int data_reply(void * data, size_t data_length);
     132extern int data_reply(void * data, size_t data_length);
    133133
    134134/** Refreshes answer structure and parameters count.
    … …  
    137137 *  @param[in,out] answer_count The number of answer parameters.
    138138 */
    139 void refresh_answer(ipc_call_t * answer, int * answer_count);
     139extern void refresh_answer(ipc_call_t * answer, int * answer_count);
    140140
    141141#endif

  • uspace/lib/socket/include/packet/packet.h

    r7d6fe4db r849ed54  
    8989 *  @returns NULL if the mapping does not exist.
    9090 */
    91 packet_t pm_find(packet_id_t packet_id);
     91extern packet_t pm_find(packet_id_t packet_id);
    9292
    9393/** Adds the packet mapping.
    … …  
    9898 *  @returns ENOMEM if there is not enough memory left.
    9999 */
    100 int pm_add(packet_t packet);
     100extern int pm_add(packet_t packet);
    101101
    102102/** Initializes the packet map.
    … …  
    104104 *  @returns ENOMEM if there is not enough memory left.
    105105 */
    106 int pm_init(void);
     106extern int pm_init(void);
    107107
    108108/** Releases the packet map.
    109109 */
    110 void pm_destroy(void);
     110extern void pm_destroy(void);
    111111
    112112/** Add packet to the sorted queue.
    … …  
    121121 *  @returns EINVAL if the packet is not valid.
    122122 */
    123 int pq_add(packet_t * first, packet_t packet, size_t order, size_t metric);
     123extern int pq_add(packet_t * first, packet_t packet, size_t order, size_t metric);
    124124
    125125/** Finds the packet with the given order.
    … …  
    130130 *  @returns NULL if the packet is not found.
    131131 */
    132 packet_t pq_find(packet_t first, size_t order);
     132extern packet_t pq_find(packet_t first, size_t order);
    133133
    134134/** Inserts packet after the given one.
    … …  
    138138 *  @returns EINVAL if etiher of the packets is invalid.
    139139 */
    140 int pq_insert_after(packet_t packet, packet_t new_packet);
     140extern int pq_insert_after(packet_t packet, packet_t new_packet);
    141141
    142142/** Detach the packet from the queue.
    … …  
    146146 *  @returns NULL if the packet is not valid.
    147147 */
    148 packet_t pq_detach(packet_t packet);
     148extern packet_t pq_detach(packet_t packet);
    149149
    150150/** Sets the packet order and metric attributes.
    … …  
    155155 *  @returns EINVAL if the packet is invalid..
    156156 */
    157 int pq_set_order(packet_t packet, size_t order, size_t metric);
     157extern int pq_set_order(packet_t packet, size_t order, size_t metric);
    158158
    159159/** Sets the packet order and metric attributes.
    … …  
    164164 *  @returns EINVAL if the packet is invalid..
    165165 */
    166 int pq_get_order(packet_t packet, size_t * order, size_t * metric);
     166extern int pq_get_order(packet_t packet, size_t * order, size_t * metric);
    167167
    168168/** Releases the whole queue.
    … …  
    171171 *  @param[in] packet_release The releasing function called for each of the packets after its detachment.
    172172 */
    173 void pq_destroy(packet_t first, void (*packet_release)(packet_t packet));
     173extern void pq_destroy(packet_t first, void (*packet_release)(packet_t packet));
    174174
    175175/** Returns the next packet in the queue.
    … …  
    179179 *  @returns NULL if the packet is not valid.
    180180 */
    181 packet_t pq_next(packet_t packet);
     181extern packet_t pq_next(packet_t packet);
    182182
    183183/** Returns the previous packet in the queue.
    … …  
    187187 *  @returns NULL if the packet is not valid.
    188188 */
    189 packet_t pq_previous(packet_t packet);
     189extern packet_t pq_previous(packet_t packet);
    190190
    191191/*@}*/

  • uspace/lib/socket/include/packet/packet_client.h

    r7d6fe4db r849ed54  
    8888 *  @returns NULL if there is not enough memory left.
    8989 */
    90 void * packet_prefix(packet_t packet, size_t length);
     90extern void * packet_prefix(packet_t packet, size_t length);
    9191
    9292/** Allocates the specified space right after the actual packet content and returns its pointer.
    … …  
    9696 *  @returns NULL if there is not enough memory left.
    9797 */
    98 void * packet_suffix(packet_t packet, size_t length);
     98extern void * packet_suffix(packet_t packet, size_t length);
    9999
    100100/** Trims the actual packet content by the specified prefix and suffix lengths.
    … …  
    106106 *  @returns ENOMEM if there is not enough memory left.
    107107 */
    108 int packet_trim(packet_t packet, size_t prefix, size_t suffix);
     108extern int packet_trim(packet_t packet, size_t prefix, size_t suffix);
    109109
    110110/** Copies the specified data to the beginning of the actual packet content.
    … …  
    117117 *  @returns ENOMEM if there is not enough memory left.
    118118 */
    119 int packet_copy_data(packet_t packet, const void * data, size_t length);
     119extern int packet_copy_data(packet_t packet, const void * data, size_t length);
    120120
    121121/** Returns the packet identifier.
    … …  
    124124 *  @returns Zero (0) if the packet is not valid.
    125125 */
    126 packet_id_t packet_get_id(const packet_t packet);
     126extern packet_id_t packet_get_id(const packet_t packet);
    127127
    128128/** Returns the packet content length.
    … …  
    131131 *  @returns Zero (0) if the packet is not valid.
    132132 */
    133 size_t packet_get_data_length(const packet_t packet);
     133extern size_t packet_get_data_length(const packet_t packet);
    134134
    135135/** Returns the pointer to the beginning of the packet content.
    … …  
    138138 *  @returns NULL if the packet is not valid.
    139139 */
    140 void * packet_get_data(const packet_t packet);
     140extern void * packet_get_data(const packet_t packet);
    141141
    142142/** Returns the stored packet addresses and their length.
    … …  
    148148 *  @returns EINVAL if the packet is not valid.
    149149 */
    150 int packet_get_addr(const packet_t packet, uint8_t ** src, uint8_t ** dest);
     150extern int packet_get_addr(const packet_t packet, uint8_t ** src, uint8_t ** dest);
    151151
    152152/** Sets the packet addresses.
    … …  
    159159 *  @returns ENOMEM if there is not enough memory left.
    160160 */
    161 int packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len);
     161extern int packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len);
    162162
    163163/** Translates the packet identifier to the packet reference.
    … …  
    172172 *  @returns Other error codes as defined for the packet_return() function.
    173173 */
    174 int packet_translate(int phone, packet_ref packet, packet_id_t packet_id);
     174extern int packet_translate(int phone, packet_ref packet, packet_id_t packet_id);
    175175
    176176/** Obtains the packet of the given dimensions.
    … …  
    184184 *  @returns NULL on error.
    185185 */
    186 packet_t packet_get_4(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix);
     186extern packet_t packet_get_4(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix);
    187187
    188188/** Obtains the packet of the given content size.
    … …  
    193193 *  @returns NULL on error.
    194194 */
    195 packet_t packet_get_1(int phone, size_t content);
     195extern packet_t packet_get_1(int phone, size_t content);
    196196
    197197/** Releases the packet queue.
    … …  
    202202 *  @param[in] packet_id The packet identifier.
    203203 */
    204 void pq_release(int phone, packet_id_t packet_id);
     204extern void pq_release(int phone, packet_id_t packet_id);
    205205
    206206/** Returns the packet copy.
    … …  
    212212 *  @returns NULL on error.
    213213 */
    214 packet_t packet_get_copy(int phone, packet_t packet);
     214extern packet_t packet_get_copy(int phone, packet_t packet);
    215215
    216216/*@}*/

  • uspace/lib/socket/include/packet/packet_header.h

    r7d6fe4db r849ed54  
    3838#define __NET_PACKET_HEADER_H__
    3939
    40 #include "packet.h"
     40#include <packet/packet.h>
    4141
    4242/** Returns the actual packet data length.

  • uspace/lib/socket/include/packet/packet_messages.h

    r7d6fe4db r849ed54  
    4040#include <ipc/ipc.h>
    4141
    42 #include "../../messages.h"
     42#include <net_messages.h>
    4343
    4444/** Packet server module messages.

  • uspace/lib/socket/include/packet/packet_server.h

    r7d6fe4db r849ed54  
    5656 *  @returns Other error codes as defined for the packet_release_wrapper() function.
    5757 */
    58 int packet_server_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
     58extern int packet_server_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count);
    5959
    6060#endif

  • uspace/lib/socket/include/socket.h

    r7d6fe4db r849ed54  
    4040#define __NET_SOCKET_H__
    4141
    42 #include "byteorder.h"
    43 #include "in.h"
    44 #include "in6.h"
    45 #include "inet.h"
    46 
    47 #include "socket_codes.h"
    48 #include "socket_errno.h"
     42#include <net_byteorder.h>
     43#include <in.h>
     44#include <in6.h>
     45#include <inet.h>
     46#include <socket_codes.h>
     47#include <socket_errno.h>
    4948
    5049/** @name Socket application programming interface
    … …  
    6564 *  @returns Other error codes as defined for the bind_service_timeout() function.
    6665 */
    67 int socket(int domain, int type, int protocol);
     66extern int socket(int domain, int type, int protocol);
    6867
    6968/** Binds the socket to a port address.
    … …  
    7776 *  @returns Other error codes as defined for the NET_SOCKET_BIND message.
    7877 */
    79 int bind(int socket_id, const struct sockaddr * my_addr, socklen_t addrlen);
     78extern int bind(int socket_id, const struct sockaddr * my_addr, socklen_t addrlen);
    8079
    8180/** Sets the number of connections waiting to be accepted.
    … …  
    8786 *  @returns Other error codes as defined for the NET_SOCKET_LISTEN message.
    8887 */
    89 int listen(int socket_id, int backlog);
     88extern int listen(int socket_id, int backlog);
    9089
    9190/** Accepts waiting socket.
    … …  
    10099 *  @returns Other error codes as defined for the NET_SOCKET_ACCEPT message.
    101100 */
    102 int accept(int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen);
     101extern int accept(int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen);
    103102
    104103/** Connects socket to the remote server.
    … …  
    112111 *  @returns Other error codes as defined for the NET_SOCKET_CONNECT message.
    113112 */
    114 int connect(int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen);
     113extern int connect(int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen);
    115114
    116115/** Closes the socket.
    … …  
    121120 *  @returns Other error codes as defined for the NET_SOCKET_CLOSE message.
    122121 */
    123 int closesocket(int socket_id);
     122extern int closesocket(int socket_id);
    124123
    125124/** Sends data via the socket.
    … …  
    134133 *  @returns Other error codes as defined for the NET_SOCKET_SEND message.
    135134 */
    136 int send(int socket_id, void * data, size_t datalength, int flags);
     135extern int send(int socket_id, void * data, size_t datalength, int flags);
    137136
    138137/** Sends data via the socket to the remote address.
    … …  
    150149 *  @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
    151150 */
    152 int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen);
     151extern int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen);
    153152
    154153/** Receives data via the socket.
    … …  
    163162 *  @returns Other error codes as defined for the NET_SOCKET_RECV message.
    164163 */
    165 int recv(int socket_id, void * data, size_t datalength, int flags);
     164extern int recv(int socket_id, void * data, size_t datalength, int flags);
    166165
    167166/** Receives data via the socket.
    … …  
    178177 *  @returns Other error codes as defined for the NET_SOCKET_RECVFROM message.
    179178 */
    180 int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen);
     179extern int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen);
    181180
    182181/** Gets socket option.
    … …  
    192191 *  @returns Other error codes as defined for the NET_SOCKET_GETSOCKOPT message.
    193192 */
    194 int getsockopt(int socket_id, int level, int optname, void * value, size_t * optlen);
     193extern int getsockopt(int socket_id, int level, int optname, void * value, size_t * optlen);
    195194
    196195/** Sets socket option.
    … …  
    206205 *  @returns Other error codes as defined for the NET_SOCKET_SETSOCKOPT message.
    207206 */
    208 int setsockopt(int socket_id, int level, int optname, const void * value, size_t optlen);
     207extern int setsockopt(int socket_id, int level, int optname, const void * value, size_t optlen);
    209208
    210209/*@}*/

  • uspace/lib/socket/include/socket_core.h

    r7d6fe4db r849ed54  
    4040#include <sys/types.h>
    4141
    42 #include "../include/in.h"
    43 #include "../include/device.h"
    44 
    45 #include "../structures/generic_char_map.h"
    46 #include "../structures/dynamic_fifo.h"
    47 #include "../structures/int_map.h"
    48 #include "../structures/packet/packet.h"
     42#include <in.h>
     43#include <net_device.h>
     44#include <adt/generic_char_map.h>
     45#include <adt/dynamic_fifo.h>
     46#include <adt/int_map.h>
     47#include <packet/packet.h>
    4948
    5049/** Initial size of the received packet queue.
    … …  
    139138 *  @param[in] socket_release The client release callback function.
    140139 */
    141 void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
     140extern void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    142141
    143142/** Binds the socket to the port.
    … …  
    158157 *  @returns Other error codes as defined for the socket_bind_insert() function.
    159158 */
    160 int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port);
     159extern int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port);
    161160
    162161/** Binds the socket to a free port.
    … …  
    171170 *  @returns Other error codes as defined for the socket_bind_insert() function.
    172171 */
    173 int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port);
     172extern int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port);
    174173
    175174/** Creates a new socket.
    … …  
    182181 *  @returns ENOMEM if there is not enough memory left.
    183182 */
    184 int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id);
     183extern int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id);
    185184
    186185/** Destroys the socket.
    … …  
    195194 *  @returns ENOTSOCK if the socket is not found.
    196195 */
    197 int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
     196extern int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    198197
    199198/** Replies the packet or the packet queue data to the application via the socket.
    … …  
    206205 *  @returns Other error codes as defined for the data_reply() function.
    207206 */
    208 int socket_reply_packets(packet_t packet, size_t * length);
     207extern int socket_reply_packets(packet_t packet, size_t * length);
    209208
    210209/** Finds the bound port socket.
    … …  
    216215 *  @returns NULL if no socket was found.
    217216 */
    218 socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length);
     217extern socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length);
    219218
    220219/** Releases the socket port.
    … …  
    224223 *  @param[in] socket The socket to be unbound.
    225224 */
    226 void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket);
     225extern void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket);
    227226
    228227/** Adds the socket to an already bound port.
    … …  
    236235 *  @returns Other error codes as defined for the socket_port_add_core() function.
    237236 */
    238 int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length);
     237extern int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length);
    239238
    240239#endif

  • uspace/lib/socket/include/socket_messages.h

    r7d6fe4db r849ed54  
    4242#include <ipc/ipc.h>
    4343
    44 #include "../messages.h"
    45 
    46 #include "../include/socket_codes.h"
     44#include <net_messages.h>
     45#include <socket_codes.h>
    4746
    4847/** Socket client messages.

  • uspace/lib/socket/packet/packet.c

    r7d6fe4db r849ed54  
    4040#include <mem.h>
    4141#include <fibril_synch.h>
    42 //#include <stdio.h>
    4342#include <unistd.h>
    4443
    4544#include <sys/mman.h>
    4645
    47 #include "../../err.h"
    48 
    49 #include "../generic_field.h"
    50 
    51 #include "packet.h"
    52 #include "packet_header.h"
     46#include <net_err.h>
     47#include <adt/generic_field.h>
     48#include <packet/packet.h>
     49#include <packet/packet_header.h>
    5350
    5451/** Packet map page size.

  • uspace/lib/socket/packet/packet_client.c

    r7d6fe4db r849ed54  
    3838#include <mem.h>
    3939#include <unistd.h>
    40 //#include <stdio.h>
    4140
    4241#include <sys/mman.h>
    4342
    44 #include "../../messages.h"
    45 
    46 #include "packet.h"
    47 #include "packet_header.h"
    48 #include "packet_client.h"
     43#include <net_messages.h>
     44#include <packet/packet.h>
     45#include <packet/packet_header.h>
     46#include <packet/packet_client.h>
    4947
    5048int packet_copy_data(packet_t packet, const void * data, size_t length){

  • uspace/lib/socket/packet/packet_server.c

    r7d6fe4db r849ed54  
    4545#include <sys/mman.h>
    4646
    47 #include "../../err.h"
    48 #include "../../messages.h"
    49 
    50 #include "packet.h"
    51 #include "packet_client.h"
    52 #include "packet_header.h"
    53 #include "packet_messages.h"
    54 #include "packet_server.h"
     47#include <net_err.h>
     48#include <net_messages.h>
     49#include <packet/packet.h>
     50#include <packet/packet_client.h>
     51#include <packet/packet_header.h>
     52#include <packet/packet_messages.h>
     53#include <packet/packet_server.h>
    5554
    5655#define FREE_QUEUES_COUNT       7
    … …  
    9897};
    9998
    100 /** @name Packet server support functions
    101  */
    102 /*@{*/
    103 
    104 /** Returns the packet of dimensions at least as given.
    105  *  Tries to reuse free packets first.
    106  *  Creates a&nbsp;new packet aligned to the memory page size if none available.
    107  *  Locks the global data during its processing.
    108  *  @param[in] addr_len The source and destination addresses maximal length in bytes.
    109  *  @param[in] max_prefix The maximal prefix length in bytes.
    110  *  @param[in] max_content The maximal content length in bytes.
    111  *  @param[in] max_suffix The maximal suffix length in bytes.
    112  *  @returns The packet of dimensions at least as given.
    113  *  @returns NULL if there is not enough memory left.
    114  */
    115 packet_t packet_get(size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
    116 
    117 /** Releases the packet queue.
    118  *  @param[in] packet_id The first packet identifier.
    119  *  @returns EOK on success.
    120  *  @returns ENOENT if there is no such packet.
    121  */
    122 int packet_release_wrapper(packet_id_t packet_id);
    123 
    124 /** Releases the packet and returns it to the appropriate free packet queue.
    125  *  Should be used only when the global data are locked.
    126  *  @param[in] packet The packet to be released.
    127  */
    128 void packet_release(packet_t packet);
    129 
    130 /** Creates a&nbsp;new packet of dimensions at least as given.
    131  *  Should be used only when the global data are locked.
    132  *  @param[in] length The total length of the packet, including the header, the addresses and the data of the packet.
    133  *  @param[in] addr_len The source and destination addresses maximal length in bytes.
    134  *  @param[in] max_prefix The maximal prefix length in bytes.
    135  *  @param[in] max_content The maximal content length in bytes.
    136  *  @param[in] max_suffix The maximal suffix length in bytes.
    137  *  @returns The packet of dimensions at least as given.
    138  *  @returns NULL if there is not enough memory left.
    139  */
    140 packet_t packet_create(size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
     99int packet_translate(int phone, packet_ref packet, packet_id_t packet_id){
     100        if(! packet){
     101                return EINVAL;
     102        }
     103        *packet = pm_find(packet_id);
     104        return (*packet) ? EOK : ENOENT;
     105}
    141106
    142107/** Clears and initializes the packet according to the given dimensions.
    … …  
    147112 *  @param[in] max_suffix The maximal suffix length in bytes.
    148113 */
    149 void packet_init(packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix);
    150 
    151 /** Shares the packet memory block.
    152  *  @param[in] packet The packet to be shared.
    153  *  @returns EOK on success.
    154  *  @returns EINVAL if the packet is not valid.
    155  *  @returns EINVAL if the calling module does not accept the memory.
    156  *  @returns ENOMEM if the desired and actual sizes differ.
    157  *  @returns Other error codes as defined for the async_share_in_finalize() function.
    158  */
    159 int packet_reply(const packet_t packet);
    160 
    161 /*@}*/
    162 
    163 int packet_translate(int phone, packet_ref packet, packet_id_t packet_id){
    164         if(! packet){
    165                 return EINVAL;
    166         }
    167         *packet = pm_find(packet_id);
    168         return (*packet) ? EOK : ENOENT;
    169 }
    170 
    171 packet_t packet_get_4(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix){
    172         return packet_get(addr_len, max_prefix, max_content, max_suffix);
    173 }
    174 
    175 packet_t packet_get_1(int phone, size_t content){
    176         return packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX);
    177 }
    178 
    179 void pq_release(int phone, packet_id_t packet_id){
    180         (void) packet_release_wrapper(packet_id);
    181 }
    182 
    183 int packet_server_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    184         packet_t packet;
    185 
    186         *answer_count = 0;
    187         switch(IPC_GET_METHOD(*call)){
    188                 case IPC_M_PHONE_HUNGUP:
    189                         return EOK;
    190                 case NET_PACKET_CREATE_1:
    191                         packet = packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT(call), DEFAULT_SUFFIX);
    192                         if(! packet){
    193                                 return ENOMEM;
    194                         }
    195                         *answer_count = 2;
    196                         IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
    197                         IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
    198                         return EOK;
    199                 case NET_PACKET_CREATE_4:
    200                         packet = packet_get(((DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN(call)) ? IPC_GET_ADDR_LEN(call) : DEFAULT_ADDR_LEN), DEFAULT_PREFIX + IPC_GET_PREFIX(call), IPC_GET_CONTENT(call), DEFAULT_SUFFIX + IPC_GET_SUFFIX(call));
    201                         if(! packet){
    202                                 return ENOMEM;
    203                         }
    204                         *answer_count = 2;
    205                         IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
    206                         IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
    207                         return EOK;
    208                 case NET_PACKET_GET:
    209                         packet = pm_find(IPC_GET_ID(call));
    210                         if(! packet_is_valid(packet)){
    211                                 return ENOENT;
    212                         }
    213                         return packet_reply(packet);
    214                 case NET_PACKET_GET_SIZE:
    215                         packet = pm_find(IPC_GET_ID(call));
    216                         if(! packet_is_valid(packet)){
    217                                 return ENOENT;
    218                         }
    219                         IPC_SET_ARG1(*answer, (ipcarg_t) packet->length);
    220                         *answer_count = 1;
    221                         return EOK;
    222                 case NET_PACKET_RELEASE:
    223                         return packet_release_wrapper(IPC_GET_ID(call));
    224         }
    225         return ENOTSUP;
    226 }
    227 
    228 int packet_release_wrapper(packet_id_t packet_id){
    229         packet_t packet;
    230 
    231         packet = pm_find(packet_id);
    232         if(! packet_is_valid(packet)){
    233                 return ENOENT;
    234         }
    235         fibril_mutex_lock(&ps_globals.lock);
    236         pq_destroy(packet, packet_release);
    237         fibril_mutex_unlock(&ps_globals.lock);
    238         return EOK;
    239 }
    240 
    241 void packet_release(packet_t packet){
    242         int index;
    243         int result;
    244 
    245         // remove debug dump
    246 //      printf("packet %d released\n", packet->packet_id);
    247         for(index = 0; (index < FREE_QUEUES_COUNT - 1) && (packet->length > ps_globals.sizes[index]); ++ index);
    248         result = pq_add(&ps_globals.free[index], packet, packet->length, packet->length);
    249         assert(result == EOK);
    250 }
    251 
    252 packet_t packet_get(size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    253         int index;
    254         packet_t packet;
    255         size_t length;
    256 
    257         length = ALIGN_UP(sizeof(struct packet) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE);
    258         fibril_mutex_lock(&ps_globals.lock);
    259         for(index = 0; index < FREE_QUEUES_COUNT - 1; ++ index){
    260                 if(length <= ps_globals.sizes[index]){
    261                         packet = ps_globals.free[index];
    262                         while(packet_is_valid(packet) && (packet->length < length)){
    263                                 packet = pm_find(packet->next);
    264                         }
    265                         if(packet_is_valid(packet)){
    266                                 if(packet == ps_globals.free[index]){
    267                                         ps_globals.free[index] = pq_detach(packet);
    268                                 }else{
    269                                         pq_detach(packet);
    270                                 }
    271                                 packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
    272                                 fibril_mutex_unlock(&ps_globals.lock);
    273                                 // remove debug dump
    274 //                              printf("packet %d got\n", packet->packet_id);
    275                                 return packet;
    276                         }
    277                 }
    278         }
    279         packet = packet_create(length, addr_len, max_prefix, max_content, max_suffix);
    280         fibril_mutex_unlock(&ps_globals.lock);
    281         // remove debug dump
    282 //      printf("packet %d created\n", packet->packet_id);
    283         return packet;
    284 }
    285 
    286 packet_t packet_create(size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    287         ERROR_DECLARE;
    288 
    289         packet_t packet;
    290 
    291         // already locked
    292         packet = (packet_t) mmap(NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
    293         if(packet == MAP_FAILED){
    294                 return NULL;
    295         }
    296         ++ ps_globals.count;
    297         packet->packet_id = ps_globals.count;
    298         packet->length = length;
    299         packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
    300         packet->magic_value = PACKET_MAGIC_VALUE;
    301         if(ERROR_OCCURRED(pm_add(packet))){
    302                 munmap(packet, packet->length);
    303                 return NULL;
    304         }
    305         return packet;
    306 }
    307 
    308 void packet_init(packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
     114static void packet_init(packet_t packet, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
    309115        // clear the packet content
    310116        bzero(((void *) packet) + sizeof(struct packet), packet->length - sizeof(struct packet));
    … …  
    323129}
    324130
    325 int packet_reply(const packet_t packet){
     131/** Creates a&nbsp;new packet of dimensions at least as given.
     132 *  Should be used only when the global data are locked.
     133 *  @param[in] length The total length of the packet, including the header, the addresses and the data of the packet.
     134 *  @param[in] addr_len The source and destination addresses maximal length in bytes.
     135 *  @param[in] max_prefix The maximal prefix length in bytes.
     136 *  @param[in] max_content The maximal content length in bytes.
     137 *  @param[in] max_suffix The maximal suffix length in bytes.
     138 *  @returns The packet of dimensions at least as given.
     139 *  @returns NULL if there is not enough memory left.
     140 */
     141static packet_t packet_create(size_t length, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
     142        ERROR_DECLARE;
     143
     144        packet_t packet;
     145
     146        // already locked
     147        packet = (packet_t) mmap(NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0);
     148        if(packet == MAP_FAILED){
     149                return NULL;
     150        }
     151        ++ ps_globals.count;
     152        packet->packet_id = ps_globals.count;
     153        packet->length = length;
     154        packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
     155        packet->magic_value = PACKET_MAGIC_VALUE;
     156        if(ERROR_OCCURRED(pm_add(packet))){
     157                munmap(packet, packet->length);
     158                return NULL;
     159        }
     160        return packet;
     161}
     162
     163/** Returns the packet of dimensions at least as given.
     164 *  Tries to reuse free packets first.
     165 *  Creates a&nbsp;new packet aligned to the memory page size if none available.
     166 *  Locks the global data during its processing.
     167 *  @param[in] addr_len The source and destination addresses maximal length in bytes.
     168 *  @param[in] max_prefix The maximal prefix length in bytes.
     169 *  @param[in] max_content The maximal content length in bytes.
     170 *  @param[in] max_suffix The maximal suffix length in bytes.
     171 *  @returns The packet of dimensions at least as given.
     172 *  @returns NULL if there is not enough memory left.
     173 */
     174static packet_t packet_get(size_t addr_len, size_t max_prefix, size_t max_content, size_t max_suffix){
     175        int index;
     176        packet_t packet;
     177        size_t length;
     178
     179        length = ALIGN_UP(sizeof(struct packet) + 2 * addr_len + max_prefix + max_content + max_suffix, PAGE_SIZE);
     180        fibril_mutex_lock(&ps_globals.lock);
     181        for(index = 0; index < FREE_QUEUES_COUNT - 1; ++ index){
     182                if(length <= ps_globals.sizes[index]){
     183                        packet = ps_globals.free[index];
     184                        while(packet_is_valid(packet) && (packet->length < length)){
     185                                packet = pm_find(packet->next);
     186                        }
     187                        if(packet_is_valid(packet)){
     188                                if(packet == ps_globals.free[index]){
     189                                        ps_globals.free[index] = pq_detach(packet);
     190                                }else{
     191                                        pq_detach(packet);
     192                                }
     193                                packet_init(packet, addr_len, max_prefix, max_content, max_suffix);
     194                                fibril_mutex_unlock(&ps_globals.lock);
     195                                // remove debug dump
     196//                              printf("packet %d got\n", packet->packet_id);
     197                                return packet;
     198                        }
     199                }
     200        }
     201        packet = packet_create(length, addr_len, max_prefix, max_content, max_suffix);
     202        fibril_mutex_unlock(&ps_globals.lock);
     203        // remove debug dump
     204//      printf("packet %d created\n", packet->packet_id);
     205        return packet;
     206}
     207
     208packet_t packet_get_4(int phone, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_suffix){
     209        return packet_get(addr_len, max_prefix, max_content, max_suffix);
     210}
     211
     212packet_t packet_get_1(int phone, size_t content){
     213        return packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, content, DEFAULT_SUFFIX);
     214}
     215
     216/** Releases the packet and returns it to the appropriate free packet queue.
     217 *  Should be used only when the global data are locked.
     218 *  @param[in] packet The packet to be released.
     219 */
     220static void packet_release(packet_t packet){
     221        int index;
     222        int result;
     223
     224        // remove debug dump
     225//      printf("packet %d released\n", packet->packet_id);
     226        for(index = 0; (index < FREE_QUEUES_COUNT - 1) && (packet->length > ps_globals.sizes[index]); ++ index);
     227        result = pq_add(&ps_globals.free[index], packet, packet->length, packet->length);
     228        assert(result == EOK);
     229}
     230
     231/** Releases the packet queue.
     232 *  @param[in] packet_id The first packet identifier.
     233 *  @returns EOK on success.
     234 *  @returns ENOENT if there is no such packet.
     235 */
     236static int packet_release_wrapper(packet_id_t packet_id){
     237        packet_t packet;
     238
     239        packet = pm_find(packet_id);
     240        if(! packet_is_valid(packet)){
     241                return ENOENT;
     242        }
     243        fibril_mutex_lock(&ps_globals.lock);
     244        pq_destroy(packet, packet_release);
     245        fibril_mutex_unlock(&ps_globals.lock);
     246        return EOK;
     247}
     248
     249void pq_release(int phone, packet_id_t packet_id){
     250        (void) packet_release_wrapper(packet_id);
     251}
     252
     253/** Shares the packet memory block.
     254 *  @param[in] packet The packet to be shared.
     255 *  @returns EOK on success.
     256 *  @returns EINVAL if the packet is not valid.
     257 *  @returns EINVAL if the calling module does not accept the memory.
     258 *  @returns ENOMEM if the desired and actual sizes differ.
     259 *  @returns Other error codes as defined for the async_share_in_finalize() function.
     260 */
     261static int packet_reply(const packet_t packet){
    326262        ipc_callid_t callid;
    327263        size_t size;
    … …  
    337273}
    338274
     275int packet_server_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     276        packet_t packet;
     277
     278        *answer_count = 0;
     279        switch(IPC_GET_METHOD(*call)){
     280                case IPC_M_PHONE_HUNGUP:
     281                        return EOK;
     282                case NET_PACKET_CREATE_1:
     283                        packet = packet_get(DEFAULT_ADDR_LEN, DEFAULT_PREFIX, IPC_GET_CONTENT(call), DEFAULT_SUFFIX);
     284                        if(! packet){
     285                                return ENOMEM;
     286                        }
     287                        *answer_count = 2;
     288                        IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
     289                        IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
     290                        return EOK;
     291                case NET_PACKET_CREATE_4:
     292                        packet = packet_get(((DEFAULT_ADDR_LEN < IPC_GET_ADDR_LEN(call)) ? IPC_GET_ADDR_LEN(call) : DEFAULT_ADDR_LEN), DEFAULT_PREFIX + IPC_GET_PREFIX(call), IPC_GET_CONTENT(call), DEFAULT_SUFFIX + IPC_GET_SUFFIX(call));
     293                        if(! packet){
     294                                return ENOMEM;
     295                        }
     296                        *answer_count = 2;
     297                        IPC_SET_ARG1(*answer, (ipcarg_t) packet->packet_id);
     298                        IPC_SET_ARG2(*answer, (ipcarg_t) packet->length);
     299                        return EOK;
     300                case NET_PACKET_GET:
     301                        packet = pm_find(IPC_GET_ID(call));
     302                        if(! packet_is_valid(packet)){
     303                                return ENOENT;
     304                        }
     305                        return packet_reply(packet);
     306                case NET_PACKET_GET_SIZE:
     307                        packet = pm_find(IPC_GET_ID(call));
     308                        if(! packet_is_valid(packet)){
     309                                return ENOENT;
     310                        }
     311                        IPC_SET_ARG1(*answer, (ipcarg_t) packet->length);
     312                        *answer_count = 1;
     313                        return EOK;
     314                case NET_PACKET_RELEASE:
     315                        return packet_release_wrapper(IPC_GET_ID(call));
     316        }
     317        return ENOTSUP;
     318}
     319
    339320/** @}
    340321 */
Note: See TracChangeset for help on using the changeset viewer.