Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset a7811f17 in mainline for uspace/srv/net/il/ip/ip.c


Ignore:
Timestamp:
2010-11-19T21:28:02Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
a9c6b966
Parents:
45f04f8 (diff), aaa3f33a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge xxx_ref typedefs removal.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/il/ip/ip.c

    r45f04f8 ra7811f17  
    144144static int ip_get_icmp_phone(void)
    145145{
    146         ip_proto_ref proto;
     146        ip_proto_t *proto;
    147147        int phone;
    148148
     
    170170 * @returns             Other error codes as defined for the packet_set_addr().
    171171 */
    172 static int ip_prepare_icmp(packet_t packet, ip_header_ref header)
     172static int ip_prepare_icmp(packet_t packet, ip_header_t *header)
    173173{
    174174        packet_t next;
     
    187187
    188188                // get header
    189                 header = (ip_header_ref) packet_get_data(packet);
     189                header = (ip_header_t *) packet_get_data(packet);
    190190                if (!header)
    191191                        return EINVAL;
     
    234234static int
    235235ip_prepare_icmp_and_get_phone(services_t error, packet_t packet,
    236     ip_header_ref header)
     236    ip_header_t *header)
    237237{
    238238        int phone;
     
    308308 *                      nil_packet_size_req() function.
    309309 */
    310 static int ip_netif_initialize(ip_netif_ref ip_netif)
     310static int ip_netif_initialize(ip_netif_t *ip_netif)
    311311{
    312312        measured_string_t names[] = {
     
    344344                }
    345345        };
    346         measured_string_ref configuration;
     346        measured_string_t *configuration;
    347347        size_t count = sizeof(names) / sizeof(measured_string_t);
    348348        char *data;
    349349        measured_string_t address;
    350         ip_route_ref route;
     350        ip_route_t *route;
    351351        in_addr_t gateway;
    352352        int index;
     
    378378                        return ENOTSUP;
    379379                } else if (ip_netif->ipv == IPV4) {
    380                         route = (ip_route_ref) malloc(sizeof(ip_route_t));
     380                        route = (ip_route_t *) malloc(sizeof(ip_route_t));
    381381                        if (!route) {
    382382                                net_free_settings(configuration, data);
     
    491491static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
    492492{
    493         ip_netif_ref netif;
     493        ip_netif_t *netif;
    494494
    495495        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
     
    516516static int ip_device_state_message(device_id_t device_id, device_state_t state)
    517517{
    518         ip_netif_ref netif;
     518        ip_netif_t *netif;
    519519
    520520        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
     
    542542 * @returns             NULL on error.
    543543 */
    544 static ip_header_ref
    545 ip_create_middle_header(packet_t packet, ip_header_ref last)
    546 {
    547         ip_header_ref middle;
    548 
    549         middle = (ip_header_ref) packet_suffix(packet, IP_HEADER_LENGTH(last));
     544static ip_header_t *
     545ip_create_middle_header(packet_t packet, ip_header_t *last)
     546{
     547        ip_header_t *middle;
     548
     549        middle = (ip_header_t *) packet_suffix(packet, IP_HEADER_LENGTH(last));
    550550        if (!middle)
    551551                return NULL;
     
    562562 * @param[in] first     The original header to be copied.
    563563 */
    564 static void ip_create_last_header(ip_header_ref last, ip_header_ref first)
    565 {
    566         ip_option_ref option;
     564static void ip_create_last_header(ip_header_t *last, ip_header_t *first)
     565{
     566        ip_option_t *option;
    567567        size_t next;
    568568        size_t length;
     
    575575        // process all ip options
    576576        while (next < first->header_length) {
    577                 option = (ip_option_ref) (((uint8_t *) first) + next);
     577                option = (ip_option_t *) (((uint8_t *) first) + next);
    578578                // skip end or noop
    579579                if ((option->type == IPOPT_END) ||
     
    623623static int
    624624ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t packet,
    625     measured_string_ref destination)
     625    measured_string_t *destination)
    626626{
    627627        size_t length;
    628         ip_header_ref header;
    629         ip_header_ref last_header;
    630         ip_header_ref middle_header;
     628        ip_header_t *header;
     629        ip_header_t *last_header;
     630        ip_header_t *middle_header;
    631631        packet_t next;
    632632        int rc;
     
    636636                return EINVAL;
    637637
    638         header = (ip_header_ref) packet_get_data(packet);
     638        header = (ip_header_t *) packet_get_data(packet);
    639639        if (destination) {
    640640                rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
     
    660660
    661661        if (pq_next(packet)) {
    662                 last_header = (ip_header_ref) malloc(IP_HEADER_LENGTH(header));
     662                last_header = (ip_header_t *) malloc(IP_HEADER_LENGTH(header));
    663663                if (!last_header)
    664664                        return ENOMEM;
     
    666666                next = pq_next(packet);
    667667                while (pq_next(next)) {
    668                         middle_header = (ip_header_ref) packet_prefix(next,
     668                        middle_header = (ip_header_t *) packet_prefix(next,
    669669                            IP_HEADER_LENGTH(last_header));
    670670                        if (!middle_header) {
     
    698698                }
    699699
    700                 middle_header = (ip_header_ref) packet_prefix(next,
     700                middle_header = (ip_header_t *) packet_prefix(next,
    701701                    IP_HEADER_LENGTH(last_header));
    702702                if (!middle_header) {
     
    755755static int
    756756ip_fragment_packet_data(packet_t packet, packet_t new_packet,
    757     ip_header_ref header, ip_header_ref new_header, size_t length,
     757    ip_header_t *header, ip_header_t *new_header, size_t length,
    758758    const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
    759759{
     
    820820{
    821821        packet_t new_packet;
    822         ip_header_ref header;
    823         ip_header_ref middle_header;
    824         ip_header_ref last_header;
     822        ip_header_t *header;
     823        ip_header_t *middle_header;
     824        ip_header_t *last_header;
    825825        struct sockaddr *src;
    826826        struct sockaddr *dest;
     
    838838
    839839        // get header
    840         header = (ip_header_ref) packet_get_data(packet);
     840        header = (ip_header_t *) packet_get_data(packet);
    841841        if (!header)
    842842                return EINVAL;
     
    853853
    854854        // allocate as much as originally
    855         last_header = (ip_header_ref) packet_suffix(new_packet,
     855        last_header = (ip_header_t *) packet_suffix(new_packet,
    856856            IP_HEADER_LENGTH(header));
    857857        if (!last_header)
     
    993993 */
    994994static int
    995 ip_send_route(packet_t packet, ip_netif_ref netif, ip_route_ref route,
     995ip_send_route(packet_t packet, ip_netif_t *netif, ip_route_t *route,
    996996    in_addr_t *src, in_addr_t dest, services_t error)
    997997{
    998998        measured_string_t destination;
    999         measured_string_ref translation;
     999        measured_string_t *translation;
    10001000        char *data;
    10011001        int phone;
     
    10651065 * @returns             NULL if no route was found.
    10661066 */
    1067 static ip_route_ref
    1068 ip_netif_find_route(ip_netif_ref netif, in_addr_t destination)
     1067static ip_route_t *
     1068ip_netif_find_route(ip_netif_t *netif, in_addr_t destination)
    10691069{
    10701070        int index;
    1071         ip_route_ref route;
     1071        ip_route_t *route;
    10721072
    10731073        if (!netif)
     
    10931093 * @returns             NULL if no route was found.
    10941094 */
    1095 static ip_route_ref ip_find_route(in_addr_t destination) {
     1095static ip_route_t *ip_find_route(in_addr_t destination) {
    10961096        int index;
    1097         ip_route_ref route;
    1098         ip_netif_ref netif;
     1097        ip_route_t *route;
     1098        ip_netif_t *netif;
    10991099
    11001100        // start with the last netif - the newest one
     
    11191119 * @returns             NULL if no IP address was found.
    11201120 */
    1121 static in_addr_t *ip_netif_address(ip_netif_ref netif)
    1122 {
    1123         ip_route_ref route;
     1121static in_addr_t *ip_netif_address(ip_netif_t *netif)
     1122{
     1123        ip_route_t *route;
    11241124
    11251125        route = ip_routes_get_index(&netif->routes, 0);
     
    11471147    tl_received_msg_t received_msg)
    11481148{
    1149         ip_proto_ref proto;
     1149        ip_proto_t *proto;
    11501150        int index;
    11511151
     
    11531153                return EINVAL;
    11541154
    1155         proto = (ip_proto_ref) malloc(sizeof(ip_protos_t));
     1155        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
    11561156        if (!proto)
    11571157                return ENOMEM;
     
    11801180ip_device_req_local(int il_phone, device_id_t device_id, services_t netif)
    11811181{
    1182         ip_netif_ref ip_netif;
    1183         ip_route_ref route;
     1182        ip_netif_t *ip_netif;
     1183        ip_route_t *route;
    11841184        int index;
    11851185        int rc;
    11861186
    1187         ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
     1187        ip_netif = (ip_netif_t *) malloc(sizeof(ip_netif_t));
    11881188        if (!ip_netif)
    11891189                return ENOMEM;
     
    12511251{
    12521252        int addrlen;
    1253         ip_netif_ref netif;
    1254         ip_route_ref route;
     1253        ip_netif_t *netif;
     1254        ip_route_t *route;
    12551255        struct sockaddr *addr;
    12561256        struct sockaddr_in *address_in;
     
    13671367    size_t *content, size_t *suffix)
    13681368{
    1369         ip_netif_ref netif;
     1369        ip_netif_t *netif;
    13701370        int index;
    13711371
     
    14201420 * @returns             The packet destination address.
    14211421 */
    1422 static in_addr_t ip_get_destination(ip_header_ref header)
     1422static in_addr_t ip_get_destination(ip_header_t *header)
    14231423{
    14241424        in_addr_t destination;
     
    14511451 */
    14521452static int
    1453 ip_deliver_local(device_id_t device_id, packet_t packet, ip_header_ref header,
     1453ip_deliver_local(device_id_t device_id, packet_t packet, ip_header_t *header,
    14541454    services_t error)
    14551455{
    1456         ip_proto_ref proto;
     1456        ip_proto_t *proto;
    14571457        int phone;
    14581458        services_t service;
     
    15551555ip_process_packet(device_id_t device_id, packet_t packet)
    15561556{
    1557         ip_header_ref header;
     1557        ip_header_t *header;
    15581558        in_addr_t dest;
    1559         ip_route_ref route;
     1559        ip_route_t *route;
    15601560        int phone;
    15611561        struct sockaddr *addr;
     
    15641564        int rc;
    15651565
    1566         header = (ip_header_ref) packet_get_data(packet);
     1566        header = (ip_header_t *) packet_get_data(packet);
    15671567        if (!header)
    15681568                return ip_release_and_return(packet, ENOMEM);
     
    16471647    in_addr_t netmask, in_addr_t gateway)
    16481648{
    1649         ip_route_ref route;
    1650         ip_netif_ref netif;
     1649        ip_route_t *route;
     1650        ip_netif_t *netif;
    16511651        int index;
    16521652
     
    16591659        }
    16601660
    1661         route = (ip_route_ref) malloc(sizeof(ip_route_t));
     1661        route = (ip_route_t *) malloc(sizeof(ip_route_t));
    16621662        if (!route) {
    16631663                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
     
    16811681ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
    16821682{
    1683         ip_netif_ref netif;
     1683        ip_netif_t *netif;
    16841684
    16851685        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
     
    17211721        icmp_type_t type;
    17221722        icmp_code_t code;
    1723         ip_netif_ref netif;
     1723        ip_netif_t *netif;
    17241724        measured_string_t address;
    1725         ip_route_ref route;
    1726         ip_header_ref header;
     1725        ip_route_t *route;
     1726        ip_header_t *header;
    17271727
    17281728        switch (error) {
     
    17341734
    17351735                data = packet_get_data(packet);
    1736                 header = (ip_header_ref)(data + offset);
     1736                header = (ip_header_t *)(data + offset);
    17371737
    17381738                // destination host unreachable?
     
    17821782        in_addr_t *dest;
    17831783        in_addr_t *src;
    1784         ip_route_ref route;
    1785         ipv4_pseudo_header_ref header_in;
     1784        ip_route_t *route;
     1785        ipv4_pseudo_header_t *header_in;
    17861786
    17871787        if (!destination || (addrlen <= 0))
     
    18291829
    18301830        *headerlen = sizeof(*header_in);
    1831         header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
     1831        header_in = (ipv4_pseudo_header_t *) malloc(*headerlen);
    18321832        if (!header_in)
    18331833                return ENOMEM;
Note: See TracChangeset for help on using the changeset viewer.