Changes in / [3da12d74:9ce7eb5] in mainline


Ignore:
Location:
uspace
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/netstart/Makefile

    r3da12d74 r9ce7eb5  
    2929
    3030USPACE_PREFIX = ../..
    31 LIBS = $(LIBNET_PREFIX)/libnet.a
    32 EXTRA_CFLAGS = -I$(LIBNET_PREFIX)/include
     31LIBS =
     32EXTRA_CFLAGS =
    3333
    3434BINARY = netstart
  • uspace/lib/c/generic/net/modules.c

    r3da12d74 r9ce7eb5  
    4141#include <async.h>
    4242#include <malloc.h>
    43 #include <err.h>
     43#include <errno.h>
    4444#include <sys/time.h>
    4545
     
    137137    ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
    138138{
    139         ERROR_DECLARE;
     139        int rc;
    140140       
    141141        /* Connect to the needed service */
     
    144144                /* Request the bidirectional connection */
    145145                ipcarg_t phonehash;
    146                 if (ERROR_OCCURRED(ipc_connect_to_me(phone, arg1, arg2, arg3,
    147                     &phonehash))) {
     146               
     147                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
     148                if (rc != EOK) {
    148149                        ipc_hangup(phone);
    149                         return ERROR_CODE;
     150                        return rc;
    150151                }
    151152                async_new_connection(phonehash, 0, NULL, client_receiver);
     
    212213int data_receive(void **data, size_t *length)
    213214{
    214         ERROR_DECLARE;
    215 
    216215        ipc_callid_t callid;
     216        int rc;
    217217
    218218        if (!data || !length)
     
    229229
    230230        // fetch the data
    231         if (ERROR_OCCURRED(async_data_write_finalize(callid, *data, *length))) {
     231        rc = async_data_write_finalize(callid, *data, *length);
     232        if (rc != EOK) {
    232233                free(data);
    233                 return ERROR_CODE;
     234                return rc;
    234235        }
    235236
  • uspace/lib/c/generic/net/packet.c

    r3da12d74 r9ce7eb5  
    4141#include <unistd.h>
    4242#include <errno.h>
    43 #include <err.h>
    4443
    4544#include <sys/mman.h>
     
    9190int pm_init(void)
    9291{
    93         ERROR_DECLARE;
     92        int rc;
    9493
    9594        fibril_rwlock_initialize(&pm_globals.lock);
     95       
    9696        fibril_rwlock_write_lock(&pm_globals.lock);
    97         ERROR_PROPAGATE(gpm_initialize(&pm_globals.packet_map));
     97        rc = gpm_initialize(&pm_globals.packet_map);
    9898        fibril_rwlock_write_unlock(&pm_globals.lock);
    99         return EOK;
     99       
     100        return rc;
    100101}
    101102
     
    139140int pm_add(packet_t packet)
    140141{
    141         ERROR_DECLARE;
    142 
    143142        packet_map_ref map;
     143        int rc;
    144144
    145145        if (!packet_is_valid(packet))
     
    160160                        }
    161161                        bzero(map, sizeof(packet_map_t));
    162                         if ((ERROR_CODE =
    163                             gpm_add(&pm_globals.packet_map, map)) < 0) {
     162                        rc = gpm_add(&pm_globals.packet_map, map);
     163                        if (rc < 0) {
    164164                                fibril_rwlock_write_unlock(&pm_globals.lock);
    165165                                free(map);
    166                                 return ERROR_CODE;
     166                                return rc;
    167167                        }
    168168                } while (PACKET_MAP_PAGE(packet->packet_id) >=
  • uspace/lib/c/generic/net/socket_client.c

    r3da12d74 r9ce7eb5  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 #include <err.h>
    4645
    4746#include <ipc/services.h>
     
    212211static void socket_connection(ipc_callid_t iid, ipc_call_t * icall)
    213212{
    214         ERROR_DECLARE;
    215 
    216213        ipc_callid_t callid;
    217214        ipc_call_t call;
    218215        socket_ref socket;
     216        int rc;
    219217
    220218loop:
     
    231229                    SOCKET_GET_SOCKET_ID(call));
    232230                if (!socket) {
    233                         ERROR_CODE = ENOTSOCK;
     231                        rc = ENOTSOCK;
    234232                        fibril_rwlock_read_unlock(&socket_globals.lock);
    235233                        break;
     
    240238                        fibril_mutex_lock(&socket->receive_lock);
    241239                        // push the number of received packet fragments
    242                         if (!ERROR_OCCURRED(dyn_fifo_push(&socket->received,
     240                        rc = dyn_fifo_push(&socket->received,
    243241                            SOCKET_GET_DATA_FRAGMENTS(call),
    244                             SOCKET_MAX_RECEIVED_SIZE))) {
     242                            SOCKET_MAX_RECEIVED_SIZE);
     243                        if (rc == EOK) {
    245244                                // signal the received packet
    246245                                fibril_condvar_signal(&socket->receive_signal);
     
    252251                        // push the new socket identifier
    253252                        fibril_mutex_lock(&socket->accept_lock);
    254                         if (!ERROR_OCCURRED(dyn_fifo_push(&socket->accepted,
    255                             1, SOCKET_MAX_ACCEPTED_SIZE))) {
     253                        rc = dyn_fifo_push(&socket->accepted, 1,
     254                            SOCKET_MAX_ACCEPTED_SIZE);
     255                        if (rc != EOK) {
    256256                                // signal the accepted socket
    257257                                fibril_condvar_signal(&socket->accept_signal);
     
    261261
    262262                default:
    263                         ERROR_CODE = ENOTSUP;
     263                        rc = ENOTSUP;
    264264                }
    265265
     
    280280
    281281        default:
    282                 ERROR_CODE = ENOTSUP;
    283         }
    284 
    285         ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
     282                rc = ENOTSUP;
     283        }
     284
     285        ipc_answer_0(callid, (ipcarg_t) rc);
    286286        goto loop;
    287287}
     
    405405int socket(int domain, int type, int protocol)
    406406{
    407         ERROR_DECLARE;
    408 
    409407        socket_ref socket;
    410408        int phone;
     
    413411        ipcarg_t fragment_size;
    414412        ipcarg_t header_size;
     413        int rc;
    415414
    416415        // find the appropriate service
     
    479478        }
    480479
    481         if (ERROR_OCCURRED((int) async_req_3_3(phone, NET_SOCKET, socket_id, 0,
    482             service, NULL, &fragment_size, &header_size))) {
     480        rc = (int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
     481            &fragment_size, &header_size);
     482        if (rc != EOK) {
    483483                fibril_rwlock_write_unlock(&socket_globals.lock);
    484484                free(socket);
    485                 return ERROR_CODE;
     485                return rc;
    486486        }
    487487
     
    492492        socket_initialize(socket, socket_id, phone, service);
    493493        // store the new socket
    494         ERROR_CODE = sockets_add(socket_get_sockets(), socket_id, socket);
     494        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    495495
    496496        fibril_rwlock_write_unlock(&socket_globals.lock);
    497         if (ERROR_CODE < 0) {
     497        if (rc < 0) {
    498498                dyn_fifo_destroy(&socket->received);
    499499                dyn_fifo_destroy(&socket->accepted);
     
    501501                async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
    502502                    service);
    503                 return ERROR_CODE;
     503                return rc;
    504504        }
    505505
     
    770770int closesocket(int socket_id)
    771771{
    772         ERROR_DECLARE;
    773 
    774772        socket_ref socket;
     773        int rc;
    775774
    776775        fibril_rwlock_write_lock(&socket_globals.lock);
     
    787786
    788787        // request close
    789         ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    790             (ipcarg_t) socket->socket_id, 0, socket->service));
     788        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
     789            (ipcarg_t) socket->socket_id, 0, socket->service);
     790        if (rc != EOK) {
     791                fibril_rwlock_write_unlock(&socket_globals.lock);
     792                return rc;
     793        }
    791794        // free the socket structure
    792795        socket_destroy(socket);
  • uspace/srv/net/net/net.c

    r3da12d74 r9ce7eb5  
    4242#include <ddi.h>
    4343#include <errno.h>
    44 #include <err.h>
    4544#include <malloc.h>
    4645#include <stdio.h>
     
    9291    const char *value)
    9392{
    94         ERROR_DECLARE;
     93        int rc;
    9594       
    9695        measured_string_ref setting =
     
    10099       
    101100        /* Add the configuration setting */
    102         if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {
     101        rc = measured_strings_add(configuration, name, 0, setting);
     102        if (rc != EOK) {
    103103                free(setting);
    104                 return ERROR_CODE;
     104                return rc;
    105105        }
    106106       
     
    110110/** Generate new system-unique device identifier.
    111111 *
    112  * @returns The system-unique devic identifier.
    113  *
     112 * @returns             The system-unique devic identifier.
    114113 */
    115114static device_id_t generate_new_device_id(void)
     
    120119static int parse_line(measured_strings_ref configuration, char *line)
    121120{
    122         ERROR_DECLARE;
     121        int rc;
    123122       
    124123        /* From the beginning */
     
    170169       
    171170        /* Add the configuration setting */
    172         if (ERROR_OCCURRED(measured_strings_add(configuration, name, 0, setting))) {
     171        rc = measured_strings_add(configuration, name, 0, setting);
     172        if (rc != EOK) {
    173173                free(setting);
    174                 return ERROR_CODE;
     174                return rc;
    175175        }
    176176       
     
    181181    measured_strings_ref configuration)
    182182{
    183         ERROR_DECLARE;
    184        
    185183        printf("%s: Reading configuration file %s/%s\n", NAME, directory, filename);
    186184       
     
    206204                        if (index >= BUFFER_SIZE) {
    207205                                line[BUFFER_SIZE - 1] = '\0';
    208                                 fprintf(stderr, "%s: Configuration line %u too long: %s\n",
    209                                     NAME, line_number, line);
     206                                fprintf(stderr, "%s: Configuration line %u too "
     207                                    "long: %s\n", NAME, line_number, line);
    210208                               
    211209                                /* No space left in the line buffer */
    212210                                return EOVERFLOW;
    213                         } else {
    214                                 /* Append the character */
    215                                 line[index] = (char) read;
    216                                 index++;
    217211                        }
     212                        /* Append the character */
     213                        line[index] = (char) read;
     214                        index++;
    218215                } else {
    219216                        /* On error or new line */
    220217                        line[index] = '\0';
    221218                        line_number++;
    222                         if (ERROR_OCCURRED(parse_line(configuration, line)))
    223                                 fprintf(stderr, "%s: Configuration error on line %u: %s\n",
    224                                     NAME, line_number, line);
     219                        if (parse_line(configuration, line) != EOK) {
     220                                fprintf(stderr, "%s: Configuration error on "
     221                                    "line %u: %s\n", NAME, line_number, line);
     222                        }
    225223                       
    226224                        index = 0;
     
    270268static int net_initialize(async_client_conn_t client_connection)
    271269{
    272         ERROR_DECLARE;
     270        int rc;
    273271       
    274272        netifs_initialize(&net_globals.netifs);
     
    278276       
    279277        // TODO: dynamic configuration
    280         ERROR_PROPAGATE(read_configuration());
    281        
    282         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    283             LO_NAME, LO_FILENAME, SERVICE_LO, 0, connect_to_service));
    284         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    285             DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service));
    286         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    287             ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0,
    288             connect_to_service));
    289         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules,
    290             NILDUMMY_NAME, NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0,
    291             connect_to_service));
     278        rc = read_configuration();
     279        if (rc != EOK)
     280                return rc;
     281       
     282        rc = add_module(NULL, &net_globals.modules, LO_NAME, LO_FILENAME,
     283            SERVICE_LO, 0, connect_to_service);
     284        if (rc != EOK)
     285                return rc;
     286        rc = add_module(NULL, &net_globals.modules, DP8390_NAME,
     287            DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);
     288        if (rc != EOK)
     289                return rc;
     290        rc = add_module(NULL, &net_globals.modules, ETHERNET_NAME,
     291            ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
     292        if (rc != EOK)
     293                return rc;
     294        rc = add_module(NULL, &net_globals.modules, NILDUMMY_NAME,
     295            NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
     296        if (rc != EOK)
     297                return rc;
    292298       
    293299        /* Build specific initialization */
     
    314320static int net_module_start(async_client_conn_t client_connection)
    315321{
    316         ERROR_DECLARE;
     322        ipcarg_t phonehash;
     323        int rc;
    317324       
    318325        async_set_client_connection(client_connection);
    319         ERROR_PROPAGATE(pm_init());
    320        
    321         ipcarg_t phonehash;
    322        
    323         if (ERROR_OCCURRED(net_initialize(client_connection)) ||
    324             ERROR_OCCURRED(REGISTER_ME(SERVICE_NETWORKING, &phonehash))) {
    325                 pm_destroy();
    326                 return ERROR_CODE;
    327         }
     326        rc = pm_init();
     327        if (rc != EOK)
     328                return rc;
     329       
     330       
     331        rc = net_initialize(client_connection);
     332        if (rc != EOK)
     333                goto out;
     334       
     335        rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);
     336        if (rc != EOK)
     337                goto out;
    328338       
    329339        async_manager();
    330        
     340
     341out:
    331342        pm_destroy();
    332         return EOK;
     343        return rc;
    333344}
    334345
     
    415426static int start_device(netif_t *netif)
    416427{
    417         ERROR_DECLARE;
     428        int rc;
    418429       
    419430        /* Mandatory netif */
     
    456467        int io = setting ? strtol(setting->value, NULL, 16) : 0;
    457468       
    458         ERROR_PROPAGATE(netif_probe_req_remote(netif->driver->phone, netif->id, irq, io));
     469        rc = netif_probe_req_remote(netif->driver->phone, netif->id, irq, io);
     470        if (rc != EOK)
     471                return rc;
    459472       
    460473        /* Network interface layer startup */
     
    468481                int mtu = setting ? strtol(setting->value, NULL, 10) : 0;
    469482               
    470                 ERROR_PROPAGATE(nil_device_req(netif->nil->phone, netif->id, mtu,
    471                     netif->driver->service));
     483                rc = nil_device_req(netif->nil->phone, netif->id, mtu,
     484                    netif->driver->service);
     485                if (rc != EOK)
     486                        return rc;
    472487               
    473488                internet_service = netif->nil->service;
     
    478493        switch (netif->il->service) {
    479494        case SERVICE_IP:
    480                 ERROR_PROPAGATE(ip_device_req(netif->il->phone, netif->id,
    481                     internet_service));
     495                rc = ip_device_req(netif->il->phone, netif->id,
     496                    internet_service);
     497                if (rc != EOK)
     498                        return rc;
    482499                break;
    483500        default:
     
    485502        }
    486503       
    487         ERROR_PROPAGATE(netif_start_req_remote(netif->driver->phone, netif->id));
    488         return EOK;
     504        return netif_start_req_remote(netif->driver->phone, netif->id);
    489505}
    490506
     
    504520static int startup(void)
    505521{
    506         ERROR_DECLARE;
    507        
    508522        const char *conf_files[] = {
    509523                "lo",
     
    511525        };
    512526        size_t count = sizeof(conf_files) / sizeof(char *);
     527        int rc;
    513528       
    514529        size_t i;
     
    522537                        return EXDEV;
    523538               
    524                 ERROR_PROPAGATE(measured_strings_initialize(&netif->configuration));
     539                rc = measured_strings_initialize(&netif->configuration);
     540                if (rc != EOK)
     541                        return rc;
    525542               
    526543                /* Read configuration files */
    527                 if (ERROR_OCCURRED(read_netif_configuration(conf_files[i], netif))) {
     544                rc = read_netif_configuration(conf_files[i], netif);
     545                if (rc != EOK) {
    528546                        measured_strings_destroy(&netif->configuration);
    529547                        free(netif);
    530                         return ERROR_CODE;
     548                        return rc;
    531549                }
    532550               
     
    554572                 * and needed modules.
    555573                 */
    556                 if ((ERROR_OCCURRED(char_map_add(&net_globals.netif_names,
    557                     netif->name, 0, index))) || (ERROR_OCCURRED(start_device(netif)))) {
     574                rc = char_map_add(&net_globals.netif_names, netif->name, 0,
     575                    index);
     576                if (rc != EOK) {
    558577                        measured_strings_destroy(&netif->configuration);
    559578                        netifs_exclude_index(&net_globals.netifs, index);
    560                         return ERROR_CODE;
     579                        return rc;
     580                }
     581               
     582                rc = start_device(netif);
     583                if (rc != EOK) {
     584                        measured_strings_destroy(&netif->configuration);
     585                        netifs_exclude_index(&net_globals.netifs, index);
     586                        return rc;
    561587                }
    562588               
     
    594620    int *answer_count)
    595621{
    596         ERROR_DECLARE;
    597        
    598622        measured_string_ref strings;
    599623        char *data;
     624        int rc;
    600625       
    601626        *answer_count = 0;
     
    604629                return EOK;
    605630        case NET_NET_GET_DEVICE_CONF:
    606                 ERROR_PROPAGATE(measured_strings_receive(&strings, &data,
    607                     IPC_GET_COUNT(call)));
     631                rc = measured_strings_receive(&strings, &data,
     632                    IPC_GET_COUNT(call));
     633                if (rc != EOK)
     634                        return rc;
    608635                net_get_device_conf_req(0, IPC_GET_DEVICE(call), &strings,
    609636                    IPC_GET_COUNT(call), NULL);
     
    612639                free(data);
    613640               
    614                 ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));
     641                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
    615642                free(strings);
    616                 return ERROR_CODE;
     643                return rc;
    617644        case NET_NET_GET_CONF:
    618                 ERROR_PROPAGATE(measured_strings_receive(&strings, &data,
    619                     IPC_GET_COUNT(call)));
     645                rc = measured_strings_receive(&strings, &data,
     646                    IPC_GET_COUNT(call));
     647                if (rc != EOK)
     648                        return rc;
    620649                net_get_conf_req(0, &strings, IPC_GET_COUNT(call), NULL);
    621650               
     
    623652                free(data);
    624653               
    625                 ERROR_CODE = measured_strings_reply(strings, IPC_GET_COUNT(call));
     654                rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
    626655                free(strings);
    627                 return ERROR_CODE;
     656                return rc;
    628657        case NET_NET_STARTUP:
    629658                return startup();
    630659        }
     660       
    631661        return ENOTSUP;
    632662}
     
    670700int main(int argc, char *argv[])
    671701{
    672         ERROR_DECLARE;
    673        
    674         if (ERROR_OCCURRED(net_module_start(net_client_connection))) {
    675                 fprintf(stderr, "%s: net_module_start error %i\n", NAME, ERROR_CODE);
    676                 return ERROR_CODE;
     702        int rc;
     703       
     704        rc = net_module_start(net_client_connection);
     705        if (rc != EOK) {
     706                fprintf(stderr, "%s: net_module_start error %i\n", NAME, rc);
     707                return rc;
    677708        }
    678709       
  • uspace/srv/net/net/net_standalone.c

    r3da12d74 r9ce7eb5  
    4242#include <ipc/ipc.h>
    4343#include <ipc/net.h>
     44#include <errno.h>
    4445
    4546#include <ip_interface.h>
     
    6061int net_initialize_build(async_client_conn_t client_connection)
    6162{
    62         ERROR_DECLARE;
     63        int rc;
    6364       
    6465        task_id_t task_id = spawn("/srv/ip");
     
    6667                return EINVAL;
    6768       
    68         ERROR_PROPAGATE(add_module(NULL, &net_globals.modules, IP_NAME,
    69             IP_FILENAME, SERVICE_IP, task_id, ip_connect_module));
     69        rc = add_module(NULL, &net_globals.modules, IP_NAME,
     70            IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
     71        if (rc != EOK)
     72                return rc;
    7073       
    7174        if (!spawn("/srv/icmp"))
Note: See TracChangeset for help on using the changeset viewer.