github.com/schwarzm/garden-linux@v0.0.0-20150507151835-33bca2147c47/old/linux_backend/src/wsh/msg.c (about)

     1  #define _GNU_SOURCE
     2  
     3  #include <assert.h>
     4  #include <errno.h>
     5  #include <stdio.h>
     6  #include <stdlib.h>
     7  #include <string.h>
     8  #include <sys/types.h>
     9  #include <unistd.h>
    10  
    11  #include "msg.h"
    12  #include "pwd.h"
    13  
    14  int msg_array_import(msg__array_t * a, int count, const char ** ptr) {
    15    size_t off = 0;
    16    size_t len = 0;
    17    int i;
    18  
    19    a->count = count;
    20    memset(a->buf, 0, sizeof(a->buf));
    21  
    22    for (i = 0; i < count; i++) {
    23      len = strlen(ptr[i]);
    24  
    25      if ((sizeof(a->buf) - off) < (len + 1)) {
    26        return -1;
    27      }
    28  
    29      memcpy(a->buf + off, ptr[i], len);
    30      off += len + 1;
    31    }
    32  
    33    return 0;
    34  }
    35  
    36  const char ** msg_array_export(msg__array_t * a) {
    37    const char ** ptr;
    38    size_t off = 0;
    39    size_t len = 0;
    40    int i;
    41  
    42    ptr = malloc(sizeof(const char *) * (a->count + 1));
    43    assert(ptr != NULL);
    44  
    45    for (i = 0; i < a->count; i++) {
    46      ptr[i] = &a->buf[off];
    47      len = strlen(ptr[i]);
    48      off += len + 1;
    49    }
    50  
    51    ptr[i] = NULL;
    52  
    53    return ptr;
    54  }
    55  
    56  #define _R(X, Y, Z) { X, #X, { Y, Z } }
    57  
    58  static struct {
    59    int id;
    60    const char* name;
    61    struct rlimit rlim;
    62  } rlimits[] = {
    63    _R(RLIMIT_AS, RLIM_INFINITY, RLIM_INFINITY),
    64    _R(RLIMIT_CORE, 0, 0),
    65    _R(RLIMIT_CPU, RLIM_INFINITY, RLIM_INFINITY),
    66    _R(RLIMIT_DATA, RLIM_INFINITY, RLIM_INFINITY),
    67    _R(RLIMIT_FSIZE, RLIM_INFINITY, RLIM_INFINITY),
    68    _R(RLIMIT_LOCKS, RLIM_INFINITY, RLIM_INFINITY),
    69    _R(RLIMIT_MEMLOCK, 65536, 65536),
    70    _R(RLIMIT_MSGQUEUE, 819200, 819200),
    71    _R(RLIMIT_NICE, 0, 0),
    72    _R(RLIMIT_NOFILE, 1024, 1024),
    73    _R(RLIMIT_NPROC, 1024, 1024),
    74    _R(RLIMIT_RSS, RLIM_INFINITY, RLIM_INFINITY),
    75    _R(RLIMIT_RTPRIO, 0, 0),
    76    _R(RLIMIT_SIGPENDING, 1024, 1024),
    77    _R(RLIMIT_STACK, 8192 * 1024, 8192 * 1024),
    78  };
    79  
    80  #undef _R
    81  
    82  int msg_rlimit_import(msg__rlimit_t *r) {
    83    int i;
    84    struct rlimit rlim;
    85    char *value;
    86    int rv;
    87  
    88    r->count = 0;
    89    memset(r->rlim, 0, sizeof(r->rlim));
    90  
    91    for (i = 0; i < (sizeof(rlimits)/sizeof(rlimits[0])); i++) {
    92      rlim = rlimits[i].rlim;
    93      value = getenv(rlimits[i].name);
    94      if (value != NULL) {
    95        rv = sscanf(value, "%ld %ld", &rlim.rlim_cur, &rlim.rlim_max);
    96        if (rv > 0) {
    97          if (rv == 1) {
    98            rlim.rlim_max = rlim.rlim_cur;
    99          }
   100        } else {
   101          errno = EINVAL;
   102          return -1;
   103        }
   104      }
   105  
   106      r->rlim[r->count].id = rlimits[i].id;
   107      r->rlim[r->count].rlim = rlim;
   108      r->count++;
   109    }
   110  
   111    return 0;
   112  }
   113  
   114  int msg_rlimit_export(msg__rlimit_t *r) {
   115    int i;
   116    int rv;
   117  
   118    for (i = 0; i < r->count; i++) {
   119      rv = setrlimit(r->rlim[i].id, &r->rlim[i].rlim);
   120      if (rv == -1) {
   121        fprintf(stderr, "%d\n", r->rlim[i].id);
   122        return rv;
   123      }
   124    }
   125  
   126    return 0;
   127  }
   128  
   129  int msg_user_import(msg__user_t *u, const char *name) {
   130    int rv;
   131  
   132    if (name != NULL) {
   133      rv = snprintf(u->name, sizeof(u->name), "%s", name);
   134      assert(rv < sizeof(u->name));
   135    }
   136  
   137    return 0;
   138  }
   139  
   140  int msg_user_export(msg__user_t *u, struct passwd *pw) {
   141    ((void) u);
   142  
   143    int rv;
   144  
   145    rv = setgid(pw->pw_gid);
   146    if (rv == -1) {
   147      return rv;
   148    }
   149  
   150    rv = setuid(pw->pw_uid);
   151    if (rv == -1) {
   152      return rv;
   153    }
   154  
   155    return 0;
   156  }
   157  
   158  int msg_dir_import(msg__dir_t *d, const char *dir) {
   159    int rv;
   160  
   161    if (dir != NULL) {
   162      rv = snprintf(d->path, sizeof(d->path), "%s", dir);
   163      assert(rv < sizeof(d->path));
   164    }
   165  
   166    return 0;
   167  }
   168  
   169  void msg_request_init(msg_request_t *req) {
   170    memset(req, 0, sizeof(*req));
   171    req->version = MSG_VERSION;
   172  }
   173  
   174  void msg_response_init(msg_response_t *res) {
   175    memset(res, 0, sizeof(*res));
   176    res->version = MSG_VERSION;
   177  }