Changeset 8bd38d6 in rtems-libbsd


Ignore:
Timestamp:
May 2, 2018, 6:58:48 AM (12 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
647dd08ae2aa69b935c2847ea450fb824322ecae, c6261f97870562d4c797cfb1ff1ba0affb85a916
Children:
b2eb48c
Parents:
bd09f9f
git-author:
Sebastian Huber <sebastian.huber@…> (05/02/18 06:58:48)
git-committer:
Sebastian Huber <sebastian.huber@…> (05/08/18 04:50:17)
Message:

dhcpcd: Add rtems_dhcpcd_start()

Use it throughout to start the DHCP client (dhcpcd).

Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • dhcpcd/dhcpcd.c

    rbd09f9f r8bd38d6  
    11111111
    11121112#ifdef __rtems__
     1113#include <rtems/dhcpcd.h>
    11131114#include <rtems/libio.h>
     1115
     1116#include <assert.h>
     1117
     1118rtems_recursive_mutex dhcpcd_mutex =
     1119    RTEMS_RECURSIVE_MUTEX_INITIALIZER("dhcpcd");
     1120
     1121static bool dhcpcd_initialized;
    11141122
    11151123struct getopt_data dhcpcd_getopt_data;
     
    11181126main(int argc, char **argv);
    11191127
    1120 int rtems_bsd_command_dhcpcd(int argc, char **argv)
    1121 {
     1128static void
     1129dhcpcd_task(rtems_task_argument arg)
     1130{
     1131        char *default_argv[] = { "dhcpcd", NULL };
     1132        const rtems_dhcpcd_config *config;
     1133        int argc;
     1134        char **argv;
    11221135        int exit_code;
    11231136
     1137        config = (const rtems_dhcpcd_config *)arg;
     1138
     1139        if (config != NULL) {
     1140                argc = config->argc;
     1141                argv = config->argv;
     1142        } else {
     1143                argc = RTEMS_BSD_ARGC(default_argv);
     1144                argv = default_argv;
     1145        }
     1146
     1147        if (config != NULL && config->prepare != NULL) {
     1148                (*config->prepare)(config, argc, argv);
     1149        }
     1150
    11241151        rtems_mkdir(DBDIR, S_IRWXU | S_IRWXG | S_IRWXO);
    1125 
    11261152        exit_code = rtems_bsd_program_call_main("dhcpcd", main, argc, argv);
    11271153
    1128         return exit_code;
     1154        if (config != NULL && config->destroy != NULL) {
     1155                (*config->destroy)(config, exit_code);
     1156        }
     1157
     1158        rtems_task_delete(RTEMS_SELF);
     1159}
     1160
     1161rtems_status_code
     1162rtems_dhcpcd_start(const rtems_dhcpcd_config *config)
     1163{
     1164        rtems_status_code sc;
     1165
     1166        rtems_recursive_mutex_lock(&dhcpcd_mutex);
     1167
     1168        if (!dhcpcd_initialized) {
     1169                rtems_task_priority priority;
     1170                rtems_id id;
     1171
     1172                if (config != NULL && config->priority != 0) {
     1173                        priority = config->priority;
     1174                } else {
     1175                        priority = RTEMS_MAXIMUM_PRIORITY - 1;
     1176                }
     1177
     1178                sc = rtems_task_create(rtems_build_name('D', 'H', 'C', 'P'), priority,
     1179                    2 * RTEMS_MINIMUM_STACK_SIZE, RTEMS_DEFAULT_MODES,
     1180                    RTEMS_FLOATING_POINT, &id);
     1181                if (sc == RTEMS_SUCCESSFUL) {
     1182                        dhcpcd_initialized = true;
     1183
     1184                        sc = rtems_task_start(id, dhcpcd_task, 0);
     1185                        assert(sc == RTEMS_SUCCESSFUL);
     1186                }
     1187        } else {
     1188                sc = RTEMS_INCORRECT_STATE;
     1189        }
     1190
     1191        rtems_recursive_mutex_unlock(&dhcpcd_mutex);
     1192        return sc;
    11291193}
    11301194#endif /* __rtems__ */
  • dhcpcd/namespace.h

    rbd09f9f r8bd38d6  
     1#include <rtems/thread.h>
     2
     3extern rtems_recursive_mutex dhcpcd_mutex;
     4
    15#define add_options dhcpcd_add_options
    26#define arp_announce dhcpcd_arp_announce
  • rtemsbsd/include/machine/rtems-bsd-commands.h

    rbd09f9f r8bd38d6  
    6161int rtems_bsd_command_route(int argc, char **argv);
    6262
    63 int rtems_bsd_command_dhcpcd(int argc, char **argv);
    64 
    6563int rtems_bsd_command_wpa_supplicant(int argc, char **argv);
    6664
  • rtemsbsd/rtems/rtems-bsd-init-dhcp.c

    rbd09f9f r8bd38d6  
    88
    99/*
    10  * Copyright (c) 2009-2015 embedded brains GmbH.  All rights reserved.
     10 * Copyright (c) 2009, 2018 embedded brains GmbH.  All rights reserved.
    1111 *
    1212 *  embedded brains GmbH
     
    3939
    4040#include <rtems/bsd/bsd.h>
     41#include <rtems/dhcpcd.h>
    4142
    42 #include <assert.h>
    4343#include <sysexits.h>
    4444
    45 #include <machine/rtems-bsd-commands.h>
    46 
    4745#include <bsp.h>
    48 
    49 static void
    50 dhcpcd_task(rtems_task_argument arg)
    51 {
    52         int exit_code;
    53         char *dhcpcd[] = {
    54             "dhcpcd",
    55             NULL
    56         };
    57 
    58         (void)arg;
    59 
    60         exit_code = rtems_bsd_command_dhcpcd(RTEMS_BSD_ARGC(dhcpcd), dhcpcd);
    61         assert(exit_code == EX_OK);
    62         (void)exit_code;
    63 }
    6446
    6547rtems_status_code
     
    6850        rtems_status_code sc;
    6951        int exit_code;
    70         rtems_id id;
    7152
    7253        sc = rtems_bsd_initialize();
     
    8061        }
    8162
    82         sc = rtems_task_create(
    83                 rtems_build_name('D', 'H', 'C', 'P'),
    84                 RTEMS_MAXIMUM_PRIORITY - 1,
    85                 2 * RTEMS_MINIMUM_STACK_SIZE,
    86                 RTEMS_DEFAULT_MODES,
    87                 RTEMS_FLOATING_POINT,
    88                 &id
    89         );
     63        sc = rtems_dhcpcd_start(NULL);
    9064        if (sc != RTEMS_SUCCESSFUL) {
    9165                return (RTEMS_UNSATISFIED);
    9266        }
    93 
    94         sc = rtems_task_start(id, dhcpcd_task, 0);
    95         assert(sc == RTEMS_SUCCESSFUL);
    9667
    9768        return (RTEMS_SUCCESSFUL);
  • rtemsbsd/rtems/rtems-bsd-rc-conf-net.c

    rbd09f9f r8bd38d6  
    6262
    6363#include <rtems/rtems-routes.h>
     64#include <rtems/dhcpcd.h>
    6465
    6566/*
     
    628629 */
    629630typedef struct dhcpcd_data {
     631  rtems_dhcpcd_config          config;
    630632  rtems_bsd_rc_conf_argc_argv* argc_argv;
    631633  bool                         verbose;
     
    634636
    635637static void
    636 dhcpcd_worker(rtems_task_argument arg)
    637 {
    638   dhcpcd_data*  dd = (dhcpcd_data*) arg;
    639   int           argc;
    640   const char**  argv;
    641   const char*   dhcpcd_argv[] = { "dhcpcd", NULL };
    642   int           r;
    643 
    644   if (dd->argc_argv->argc > 0) {
    645     argc = dd->argc_argv->argc;
    646     argv = dd->argc_argv->argv;
    647   }
    648   else {
    649     argc = 1;
    650     argv = dhcpcd_argv;
    651   }
     638dhcpcd_prepare(const rtems_dhcpcd_config *config, int argc, char **argv)
     639{
     640  const dhcpcd_data* dd = (const dhcpcd_data*) config;
    652641
    653642  if (dd->verbose) {
     643    int r;
     644
    654645    fprintf(stdout, "rc.conf: %s: dhcpcd ", dd->name);
    655646    for (r = 1; r < argc; ++r)
     
    657648    fprintf(stdout, "\n");
    658649  }
    659 
    660   r = rtems_bsd_command_dhcpcd(argc, argv);
    661   if (r != EX_OK)
     650}
     651
     652static void
     653dhcpcd_destroy(const rtems_dhcpcd_config *config, int exit_code)
     654{
     655  dhcpcd_data* dd = (dhcpcd_data*) config;
     656
     657  if (exit_code != EX_OK)
    662658    fprintf(stderr, "error: dhcpcd: stopped\n");
    663659
     
    665661  rtems_bsd_rc_conf_argc_argv_destroy(dd->argc_argv);
    666662  free(dd);
    667 
    668   rtems_task_delete(RTEMS_SELF);
    669663}
    670664
     
    674668  dhcpcd_data*        dd;
    675669  rtems_status_code   sc;
    676   rtems_id            id;
    677   rtems_task_priority priority = RTEMS_MAXIMUM_PRIORITY - 1;
     670  rtems_task_priority priority = 0;
    678671  char*               end = NULL;
    679672  int                 r;
     
    712705    if (dd->argc_argv->argc == 2) {
    713706      priority = strtoul(dd->argc_argv->argv[1], &end, 10);
    714       if (priority == 0 || *end != '\0')
    715         priority = RTEMS_MAXIMUM_PRIORITY - 1;
    716     }
    717   }
     707      if (*end != '\0')
     708        priority = 0;
     709    }
     710  }
     711  dd->config.priority = priority;
    718712
    719713  rtems_bsd_rc_conf_find(rc_conf, "dhcpcd_options", dd->argc_argv);
    720714
    721   sc = rtems_task_create(rtems_build_name('D', 'H', 'C', 'P'),
    722                          priority,
    723                          2 * RTEMS_MINIMUM_STACK_SIZE,
    724                          RTEMS_DEFAULT_MODES,
    725                          RTEMS_FLOATING_POINT,
    726                          &id);
    727   if (sc == RTEMS_SUCCESSFUL)
    728     sc = rtems_task_start(id, dhcpcd_worker, (rtems_task_argument) dd);
     715  if (dd->argc_argv->argc > 0) {
     716    dd->config.argc = dd->argc_argv->argc;
     717    dd->config.argv = dd->argc_argv->argv;
     718  }
     719
     720  dd->config.prepare = dhcpcd_prepare;
     721  dd->config.destroy = dhcpcd_destroy;
     722
     723  sc = rtems_dhcpcd_start(&dd->config);
    729724  if (sc != RTEMS_SUCCESSFUL) {
    730725    fprintf(stderr,
  • rtemsbsd/rtems/rtems-bsd-shell-dhcpcd.c

    rbd09f9f r8bd38d6  
    11/*
    2  * Copyright (c) 2013 embedded brains GmbH.  All rights reserved.
     2 * Copyright (c) 2013, 2018 embedded brains GmbH.  All rights reserved.
    33 *
    44 *  embedded brains GmbH
     
    3131
    3232#include <rtems/netcmds-config.h>
    33 #include <machine/rtems-bsd-commands.h>
     33
     34#include <rtems.h>
     35#include <rtems/dhcpcd.h>
     36
     37#include <stdio.h>
     38#include <stdlib.h>
     39#include <string.h>
     40
     41typedef struct {
     42        rtems_dhcpcd_config config;
     43        char *argv[RTEMS_ZERO_LENGTH_ARRAY];
     44} dhcpcd_command_config;
     45
     46static void
     47dhcpcd_command_destroy_config(const rtems_dhcpcd_config *config, int exit_code)
     48{
     49        char **argv;
     50
     51        (void)exit_code;
     52
     53        argv = config->argv;
     54        while (*argv != NULL) {
     55                free(*argv);
     56                ++argv;
     57        }
     58
     59        free(RTEMS_DECONST(rtems_dhcpcd_config *, config));
     60}
     61
     62static int
     63dhcpcd_command(int argc, char **argv)
     64{
     65        dhcpcd_command_config *config;
     66        rtems_status_code sc;
     67        int i;
     68
     69        config = calloc(1, sizeof(*config) + (argc + 1) * sizeof(char *));
     70        if (config == NULL) {
     71                fprintf(stdout, "dhcpcd error: not enough memory\n");
     72                return 1;
     73        }
     74
     75        for (i = 0; i < argc; ++i) {
     76                config->argv[i] = strdup(argv[i]);
     77                if (config->argv[i] == NULL) {
     78                        dhcpcd_command_destroy_config(&config->config, 0);
     79                        fprintf(stdout, "dhcpcd error: not enough memory\n");
     80                        return 1;
     81                }
     82        }
     83
     84        config->config.argc = argc;
     85        config->config.argv = &config->argv[0];
     86        config->config.destroy = dhcpcd_command_destroy_config;
     87
     88        sc = rtems_dhcpcd_start(&config->config);
     89        if (sc != RTEMS_SUCCESSFUL) {
     90                dhcpcd_command_destroy_config(&config->config, 0);
     91                fprintf(stdout, "dhcpcd start failed: %s\n", rtems_status_text(sc));
     92        }
     93
     94        return 0;
     95}
    3496
    3597rtems_shell_cmd_t rtems_shell_DHCPCD_Command = {
     
    3799  .usage = "dhcpcd [args]",
    38100  .topic = "net",
    39   .command = rtems_bsd_command_dhcpcd
     101  .command = dhcpcd_command
    40102};
  • testsuite/include/rtems/bsd/test/default-network-init.h

    rbd09f9f r8bd38d6  
    4949#include <rtems/bsd/bsd.h>
    5050#include <rtems/bsd/modules.h>
     51#include <rtems/dhcpcd.h>
    5152
    5253#if defined(DEFAULT_NETWORK_DHCPCD_ENABLE) && \
     
    127128#endif
    128129
     130static void
     131default_network_dhcpcd(void)
     132{
    129133#ifdef DEFAULT_NETWORK_DHCPCD_ENABLE
    130 static void
    131 default_network_dhcpcd_task(rtems_task_argument arg)
    132 {
    133134        static const char default_cfg[] = "clientid libbsd test client\n";
    134         int exit_code;
    135         char *dhcpcd[] = {
    136                 "dhcpcd",
    137                 NULL
    138         };
     135        rtems_status_code sc;
    139136        int fd;
    140137        int rv;
    141138        ssize_t n;
    142139
    143         (void)arg;
    144 
    145140        fd = open("/etc/dhcpcd.conf", O_CREAT | O_WRONLY,
    146141            S_IRWXU | S_IRWXG | S_IRWXO);
     
    160155        assert(rv == 0);
    161156
    162         exit_code = rtems_bsd_command_dhcpcd(RTEMS_BSD_ARGC(dhcpcd), dhcpcd);
    163         assert(exit_code == EXIT_SUCCESS);
    164 }
    165 #endif
    166 
    167 static void
    168 default_network_dhcpcd(void)
    169 {
    170 #ifdef DEFAULT_NETWORK_DHCPCD_ENABLE
    171         rtems_status_code sc;
    172         rtems_id id;
    173 
    174         sc = rtems_task_create(
    175                 rtems_build_name('D', 'H', 'C', 'P'),
    176                 RTEMS_MAXIMUM_PRIORITY - 1,
    177                 2 * RTEMS_MINIMUM_STACK_SIZE,
    178                 RTEMS_DEFAULT_MODES,
    179                 RTEMS_FLOATING_POINT,
    180                 &id
    181         );
    182         assert(sc == RTEMS_SUCCESSFUL);
    183 
    184         sc = rtems_task_start(id, default_network_dhcpcd_task, 0);
     157        sc = rtems_dhcpcd_start(NULL);
    185158        assert(sc == RTEMS_SUCCESSFUL);
    186159#endif
Note: See TracChangeset for help on using the changeset viewer.