mdw@git.distorted.org.uk Git - termux-packages/blob - disabled-packages/util-linux/sys-utils-ipcutils.c.patch

   1 diff -u -r ../util-linux-2.28/sys-utils/ipcutils.c ./sys-utils/ipcutils.c
   2 --- ../util-linux-2.28/sys-utils/ipcutils.c     2016-04-04 04:29:50.698566374 -0400
   3 +++ ./sys-utils/ipcutils.c      2016-06-23 06:20:15.952794444 -0400
   4 @@ -15,516 +15,63 @@
   5  # define SHMMIN 1      /* min shared segment size in bytes */
   6  #endif
   7
   8 -
   9  int ipc_msg_get_limits(struct ipc_limits *lim)
  10  {
  11 -       if (path_exist(_PATH_PROC_IPC_MSGMNI) &&
  12 -           path_exist(_PATH_PROC_IPC_MSGMNB) &&
  13 -           path_exist(_PATH_PROC_IPC_MSGMAX)) {
  14 -
  15 -               lim->msgmni = path_read_s32(_PATH_PROC_IPC_MSGMNI);
  16 -               lim->msgmnb = path_read_s32(_PATH_PROC_IPC_MSGMNB);
  17 -               lim->msgmax = path_read_s32(_PATH_PROC_IPC_MSGMAX);
  18 -       } else {
  19 -               struct msginfo msginfo;
  20 -
  21 -               if (msgctl(0, IPC_INFO, (struct msqid_ds *) &msginfo) < 0)
  22 -                       return 1;
  23 -               lim->msgmni = msginfo.msgmni;
  24 -               lim->msgmnb = msginfo.msgmnb;
  25 -               lim->msgmax = msginfo.msgmax;
  26 -       }
  27 -
  28 -       return 0;
  29 +       return -1;
  30  }
  31
  32  int ipc_sem_get_limits(struct ipc_limits *lim)
  33  {
  34 -       FILE *f;
  35 -       int rc = 0;
  36 -
  37 -       lim->semvmx = SEMVMX;
  38 -
  39 -       f = path_fopen("r", 0, _PATH_PROC_IPC_SEM);
  40 -       if (f) {
  41 -               rc = fscanf(f, "%d\t%d\t%d\t%d",
  42 -                      &lim->semmsl, &lim->semmns, &lim->semopm, &lim->semmni);
  43 -               fclose(f);
  44 -
  45 -       }
  46 -
  47 -       if (rc != 4) {
  48 -               struct seminfo seminfo = { .semmni = 0 };
  49 -               union semun arg = { .array = (ushort *) &seminfo };
  50 -
  51 -               if (semctl(0, 0, IPC_INFO, arg) < 0)
  52 -                       return 1;
  53 -               lim->semmni = seminfo.semmni;
  54 -               lim->semmsl = seminfo.semmsl;
  55 -               lim->semmns = seminfo.semmns;
  56 -               lim->semopm = seminfo.semopm;
  57 -       }
  58 -
  59 -       return 0;
  60 +       return -1;
  61  }
  62
  63  int ipc_shm_get_limits(struct ipc_limits *lim)
  64  {
  65 -       lim->shmmin = SHMMIN;
  66 -
  67 -       if (path_exist(_PATH_PROC_IPC_SHMALL) &&
  68 -           path_exist(_PATH_PROC_IPC_SHMMAX) &&
  69 -           path_exist(_PATH_PROC_IPC_SHMMNI)) {
  70 -
  71 -               lim->shmall = path_read_u64(_PATH_PROC_IPC_SHMALL);
  72 -               lim->shmmax = path_read_u64(_PATH_PROC_IPC_SHMMAX);
  73 -               lim->shmmni = path_read_u64(_PATH_PROC_IPC_SHMMNI);
  74 -
  75 -       } else {
  76 -               struct shminfo *shminfo;
  77 -               struct shmid_ds shmbuf;
  78 -
  79 -               if (shmctl(0, IPC_INFO, &shmbuf) < 0)
  80 -                       return 1;
  81 -               shminfo = (struct shminfo *) &shmbuf;
  82 -               lim->shmmni = shminfo->shmmni;
  83 -               lim->shmall = shminfo->shmall;
  84 -               lim->shmmax = shminfo->shmmax;
  85 -       }
  86 -
  87 -       return 0;
  88 +       return -1;
  89  }
  90
  91  int ipc_shm_get_info(int id, struct shm_data **shmds)
  92  {
  93 -       FILE *f;
  94 -       int i = 0, maxid;
  95 -       char buf[BUFSIZ];
  96 -       struct shm_data *p;
  97 -       struct shmid_ds dummy;
  98 -
  99 -       p = *shmds = xcalloc(1, sizeof(struct shm_data));
 100 -       p->next = NULL;
 101 -
 102 -       f = path_fopen("r", 0, _PATH_PROC_SYSV_SHM);
 103 -       if (!f)
 104 -               goto shm_fallback;
 105 -
 106 -       while (fgetc(f) != '\n');               /* skip header */
 107 -
 108 -       while (fgets(buf, sizeof(buf), f) != NULL) {
 109 -               /* scan for the first 14-16 columns (e.g. Linux 2.6.32 has 14) */
 110 -               p->shm_rss = 0xdead;
 111 -               p->shm_swp = 0xdead;
 112 -               if (sscanf(buf,
 113 -                         "%d %d  %o %"SCNu64 " %u %u  "
 114 -                         "%"SCNu64 " %u %u %u %u %"SCNi64 " %"SCNi64 " %"SCNi64
 115 -                         " %"SCNu64 " %"SCNu64 "\n",
 116 -                          &p->shm_perm.key,
 117 -                          &p->shm_perm.id,
 118 -                          &p->shm_perm.mode,
 119 -                          &p->shm_segsz,
 120 -                          &p->shm_cprid,
 121 -                          &p->shm_lprid,
 122 -                          &p->shm_nattch,
 123 -                          &p->shm_perm.uid,
 124 -                          &p->shm_perm.gid,
 125 -                          &p->shm_perm.cuid,
 126 -                          &p->shm_perm.cgid,
 127 -                          &p->shm_atim,
 128 -                          &p->shm_dtim,
 129 -                          &p->shm_ctim,
 130 -                          &p->shm_rss,
 131 -                          &p->shm_swp) < 14)
 132 -                       continue; /* ivalid line, skipped */
 133 -
 134 -               if (id > -1) {
 135 -                       /* ID specified */
 136 -                       if (id == p->shm_perm.id) {
 137 -                               i = 1;
 138 -                               break;
 139 -                       } else
 140 -                               continue;
 141 -               }
 142 -
 143 -               p->next = xcalloc(1, sizeof(struct shm_data));
 144 -               p = p->next;
 145 -               p->next = NULL;
 146 -               i++;
 147 -       }
 148 -
 149 -       if (i == 0)
 150 -               free(*shmds);
 151 -       fclose(f);
 152 -       return i;
 153 -
 154 -       /* Fallback; /proc or /sys file(s) missing. */
 155 -shm_fallback:
 156 -       maxid = shmctl(0, SHM_INFO, &dummy);
 157 -
 158 -       for (int j = 0; j <= maxid; j++) {
 159 -               int shmid;
 160 -               struct shmid_ds shmseg;
 161 -               struct ipc_perm *ipcp = &shmseg.shm_perm;
 162 -
 163 -               shmid = shmctl(j, SHM_STAT, &shmseg);
 164 -               if (shmid < 0 || (id > -1 && shmid != id)) {
 165 -                       continue;
 166 -               }
 167 -
 168 -               i++;
 169 -               p->shm_perm.key = ipcp->KEY;
 170 -               p->shm_perm.id = shmid;
 171 -               p->shm_perm.mode = ipcp->mode;
 172 -               p->shm_segsz = shmseg.shm_segsz;
 173 -               p->shm_cprid = shmseg.shm_cpid;
 174 -               p->shm_lprid = shmseg.shm_lpid;
 175 -               p->shm_nattch = shmseg.shm_nattch;
 176 -               p->shm_perm.uid = ipcp->uid;
 177 -               p->shm_perm.gid = ipcp->gid;
 178 -               p->shm_perm.cuid = ipcp->cuid;
 179 -               p->shm_perm.cgid = ipcp->cuid;
 180 -               p->shm_atim = shmseg.shm_atime;
 181 -               p->shm_dtim = shmseg.shm_dtime;
 182 -               p->shm_ctim = shmseg.shm_ctime;
 183 -               p->shm_rss = 0xdead;
 184 -               p->shm_swp = 0xdead;
 185 -
 186 -               if (id < 0) {
 187 -                       p->next = xcalloc(1, sizeof(struct shm_data));
 188 -                       p = p->next;
 189 -                       p->next = NULL;
 190 -               } else
 191 -                       break;
 192 -       }
 193 -
 194 -       if (i == 0)
 195 -               free(*shmds);
 196 -       return i;
 197 +       return -1;
 198  }
 199
 200  void ipc_shm_free_info(struct shm_data *shmds)
 201  {
 202 -       while (shmds) {
 203 -               struct shm_data *next = shmds->next;
 204 -               free(shmds);
 205 -               shmds = next;
 206 -       }
 207 +       return;
 208  }
 209
 210  static void get_sem_elements(struct sem_data *p)
 211  {
 212 -       size_t i;
 213 -
 214 -       if (!p || !p->sem_nsems || p->sem_perm.id < 0)
 215 -               return;
 216 -
 217 -       p->elements = xcalloc(p->sem_nsems, sizeof(struct sem_elem));
 218 -
 219 -       for (i = 0; i < p->sem_nsems; i++) {
 220 -               struct sem_elem *e = &p->elements[i];
 221 -               union semun arg = { .val = 0 };
 222 -
 223 -               e->semval = semctl(p->sem_perm.id, i, GETVAL, arg);
 224 -               if (e->semval < 0)
 225 -                       err(EXIT_FAILURE, _("%s failed"), "semctl(GETVAL)");
 226 -
 227 -               e->ncount = semctl(p->sem_perm.id, i, GETNCNT, arg);
 228 -               if (e->ncount < 0)
 229 -                       err(EXIT_FAILURE, _("%s failed"), "semctl(GETNCNT)");
 230 -
 231 -               e->zcount = semctl(p->sem_perm.id, i, GETZCNT, arg);
 232 -               if (e->zcount < 0)
 233 -                       err(EXIT_FAILURE, _("%s failed"), "semctl(GETZCNT)");
 234 -
 235 -               e->pid = semctl(p->sem_perm.id, i, GETPID, arg);
 236 -               if (e->pid < 0)
 237 -                       err(EXIT_FAILURE, _("%s failed"), "semctl(GETPID)");
 238 -       }
 239 +       return;
 240  }
 241
 242  int ipc_sem_get_info(int id, struct sem_data **semds)
 243  {
 244 -       FILE *f;
 245 -       int i = 0, maxid;
 246 -       struct sem_data *p;
 247 -       struct seminfo dummy;
 248 -       union semun arg;
 249 -
 250 -       p = *semds = xcalloc(1, sizeof(struct sem_data));
 251 -       p->next = NULL;
 252 -
 253 -       f = path_fopen("r", 0, _PATH_PROC_SYSV_SEM);
 254 -       if (!f)
 255 -               goto sem_fallback;
 256 -
 257 -       while (fgetc(f) != '\n') ;      /* skip header */
 258 -
 259 -       while (feof(f) == 0) {
 260 -               if (fscanf(f,
 261 -                          "%d %d  %o %" SCNu64 " %u %u %u %u %"
 262 -                           SCNi64 " %" SCNi64 "\n",
 263 -                          &p->sem_perm.key,
 264 -                          &p->sem_perm.id,
 265 -                          &p->sem_perm.mode,
 266 -                          &p->sem_nsems,
 267 -                          &p->sem_perm.uid,
 268 -                          &p->sem_perm.gid,
 269 -                          &p->sem_perm.cuid,
 270 -                          &p->sem_perm.cgid,
 271 -                          &p->sem_otime,
 272 -                          &p->sem_ctime) != 10)
 273 -                       continue;
 274 -
 275 -               if (id > -1) {
 276 -                       /* ID specified */
 277 -                       if (id == p->sem_perm.id) {
 278 -                               get_sem_elements(p);
 279 -                               i = 1;
 280 -                               break;
 281 -                       } else
 282 -                               continue;
 283 -               }
 284 -
 285 -               p->next = xcalloc(1, sizeof(struct sem_data));
 286 -               p = p->next;
 287 -               p->next = NULL;
 288 -               i++;
 289 -       }
 290 -
 291 -       if (i == 0)
 292 -               free(*semds);
 293 -       fclose(f);
 294 -       return i;
 295 -
 296 -       /* Fallback; /proc or /sys file(s) missing. */
 297 -sem_fallback:
 298 -       arg.array = (ushort *) (void *)&dummy;
 299 -       maxid = semctl(0, 0, SEM_INFO, arg);
 300 -
 301 -       for (int j = 0; j <= maxid; j++) {
 302 -               int semid;
 303 -               struct semid_ds semseg;
 304 -               struct ipc_perm *ipcp = &semseg.sem_perm;
 305 -               arg.buf = (struct semid_ds *)&semseg;
 306 -
 307 -               semid = semctl(j, 0, SEM_STAT, arg);
 308 -               if (semid < 0 || (id > -1 && semid != id)) {
 309 -                       continue;
 310 -               }
 311 -
 312 -               i++;
 313 -               p->sem_perm.key = ipcp->KEY;
 314 -               p->sem_perm.id = semid;
 315 -               p->sem_perm.mode = ipcp->mode;
 316 -               p->sem_nsems = semseg.sem_nsems;
 317 -               p->sem_perm.uid = ipcp->uid;
 318 -               p->sem_perm.gid = ipcp->gid;
 319 -               p->sem_perm.cuid = ipcp->cuid;
 320 -               p->sem_perm.cgid = ipcp->cuid;
 321 -               p->sem_otime = semseg.sem_otime;
 322 -               p->sem_ctime = semseg.sem_ctime;
 323 -
 324 -               if (id < 0) {
 325 -                       p->next = xcalloc(1, sizeof(struct sem_data));
 326 -                       p = p->next;
 327 -                       p->next = NULL;
 328 -                       i++;
 329 -               } else {
 330 -                       get_sem_elements(p);
 331 -                       break;
 332 -               }
 333 -       }
 334 -
 335 -       if (i == 0)
 336 -               free(*semds);
 337 -       return i;
 338 +       return -1;
 339  }
 340
 341  void ipc_sem_free_info(struct sem_data *semds)
 342  {
 343 -       while (semds) {
 344 -               struct sem_data *next = semds->next;
 345 -               free(semds->elements);
 346 -               free(semds);
 347 -               semds = next;
 348 -       }
 349 +       return;
 350  }
 351
 352  int ipc_msg_get_info(int id, struct msg_data **msgds)
 353  {
 354 -       FILE *f;
 355 -       int i = 0, maxid;
 356 -       struct msg_data *p;
 357 -       struct msqid_ds dummy;
 358 -       struct msqid_ds msgseg;
 359 -
 360 -       p = *msgds = xcalloc(1, sizeof(struct msg_data));
 361 -       p->next = NULL;
 362 -
 363 -       f = path_fopen("r", 0, _PATH_PROC_SYSV_MSG);
 364 -       if (!f)
 365 -               goto msg_fallback;
 366 -
 367 -       while (fgetc(f) != '\n') ;      /* skip header */
 368 -
 369 -       while (feof(f) == 0) {
 370 -               if (fscanf(f,
 371 -                          "%d %d  %o  %" SCNu64 " %" SCNu64
 372 -                          " %u %u %u %u %u %u %" SCNi64 " %" SCNi64 " %" SCNi64 "\n",
 373 -                          &p->msg_perm.key,
 374 -                          &p->msg_perm.id,
 375 -                          &p->msg_perm.mode,
 376 -                          &p->q_cbytes,
 377 -                          &p->q_qnum,
 378 -                          &p->q_lspid,
 379 -                          &p->q_lrpid,
 380 -                          &p->msg_perm.uid,
 381 -                          &p->msg_perm.gid,
 382 -                          &p->msg_perm.cuid,
 383 -                          &p->msg_perm.cgid,
 384 -                          &p->q_stime,
 385 -                          &p->q_rtime,
 386 -                          &p->q_ctime) != 14)
 387 -                       continue;
 388 -
 389 -               if (id > -1) {
 390 -                       /* ID specified */
 391 -                       if (id == p->msg_perm.id) {
 392 -                               if (msgctl(id, IPC_STAT, &msgseg) != -1)
 393 -                                       p->q_qbytes = msgseg.msg_qbytes;
 394 -                               i = 1;
 395 -                               break;
 396 -                       } else
 397 -                               continue;
 398 -               }
 399 -
 400 -               p->next = xcalloc(1, sizeof(struct msg_data));
 401 -               p = p->next;
 402 -               p->next = NULL;
 403 -               i++;
 404 -       }
 405 -
 406 -       if (i == 0)
 407 -               free(*msgds);
 408 -       fclose(f);
 409 -       return i;
 410 -
 411 -       /* Fallback; /proc or /sys file(s) missing. */
 412 -msg_fallback:
 413 -       maxid = msgctl(0, MSG_INFO, &dummy);
 414 -
 415 -       for (int j = 0; j <= maxid; j++) {
 416 -               int msgid;
 417 -               struct ipc_perm *ipcp = &msgseg.msg_perm;
 418 -
 419 -               msgid = msgctl(j, MSG_STAT, &msgseg);
 420 -               if (msgid < 0 || (id > -1 && msgid != id)) {
 421 -                       continue;
 422 -               }
 423 -
 424 -               i++;
 425 -               p->msg_perm.key = ipcp->KEY;
 426 -               p->msg_perm.id = msgid;
 427 -               p->msg_perm.mode = ipcp->mode;
 428 -               p->q_cbytes = msgseg.msg_cbytes;
 429 -               p->q_qnum = msgseg.msg_qnum;
 430 -               p->q_lspid = msgseg.msg_lspid;
 431 -               p->q_lrpid = msgseg.msg_lrpid;
 432 -               p->msg_perm.uid = ipcp->uid;
 433 -               p->msg_perm.gid = ipcp->gid;
 434 -               p->msg_perm.cuid = ipcp->cuid;
 435 -               p->msg_perm.cgid = ipcp->cgid;
 436 -               p->q_stime = msgseg.msg_stime;
 437 -               p->q_rtime = msgseg.msg_rtime;
 438 -               p->q_ctime = msgseg.msg_ctime;
 439 -               p->q_qbytes = msgseg.msg_qbytes;
 440 -
 441 -               if (id < 0) {
 442 -                       p->next = xcalloc(1, sizeof(struct msg_data));
 443 -                       p = p->next;
 444 -                       p->next = NULL;
 445 -               } else
 446 -                       break;
 447 -       }
 448 -
 449 -       if (i == 0)
 450 -               free(*msgds);
 451 -       return i;
 452 +       return -1;
 453  }
 454
 455  void ipc_msg_free_info(struct msg_data *msgds)
 456  {
 457 -       while (msgds) {
 458 -               struct msg_data *next = msgds->next;
 459 -               free(msgds);
 460 -               msgds = next;
 461 -       }
 462 +       return;
 463  }
 464
 465  void ipc_print_perms(FILE *f, struct ipc_stat *is)
 466  {
 467 -       struct passwd *pw;
 468 -       struct group *gr;
 469 -
 470 -       fprintf(f, "%-10d %-10o", is->id, is->mode & 0777);
 471 -
 472 -       if ((pw = getpwuid(is->cuid)))
 473 -               fprintf(f, " %-10s", pw->pw_name);
 474 -       else
 475 -               fprintf(f, " %-10u", is->cuid);
 476 -
 477 -       if ((gr = getgrgid(is->cgid)))
 478 -               fprintf(f, " %-10s", gr->gr_name);
 479 -       else
 480 -               fprintf(f, " %-10u", is->cgid);
 481 -
 482 -       if ((pw = getpwuid(is->uid)))
 483 -               fprintf(f, " %-10s", pw->pw_name);
 484 -       else
 485 -               fprintf(f, " %-10u", is->uid);
 486 -
 487 -       if ((gr = getgrgid(is->gid)))
 488 -               fprintf(f, " %-10s\n", gr->gr_name);
 489 -       else
 490 -               fprintf(f, " %-10u\n", is->gid);
 491 +       return;
 492  }
 493
 494  void ipc_print_size(int unit, char *msg, uint64_t size, const char *end,
 495                     int width)
 496  {
 497 -       char format[32];
 498 -
 499 -       if (!msg)
 500 -               /* NULL */ ;
 501 -       else if (msg[strlen(msg) - 1] == '=')
 502 -               printf("%s", msg);
 503 -       else if (unit == IPC_UNIT_BYTES)
 504 -               printf(_("%s (bytes) = "), msg);
 505 -       else if (unit == IPC_UNIT_KB)
 506 -               printf(_("%s (kbytes) = "), msg);
 507 -       else
 508 -               printf("%s = ", msg);
 509 -
 510 -       switch (unit) {
 511 -       case IPC_UNIT_DEFAULT:
 512 -       case IPC_UNIT_BYTES:
 513 -               sprintf(format, "%%%dju", width);
 514 -               printf(format, size);
 515 -               break;
 516 -       case IPC_UNIT_KB:
 517 -               sprintf(format, "%%%dju", width);
 518 -               printf(format, size / 1024);
 519 -               break;
 520 -       case IPC_UNIT_HUMAN:
 521 -               sprintf(format, "%%%ds", width);
 522 -               printf(format, size_to_human_string(SIZE_SUFFIX_1LETTER, size));
 523 -               break;
 524 -       default:
 525 -               /* impossible occurred */
 526 -               abort();
 527 -       }
 528 -
 529 -       if (end)
 530 -               printf("%s", end);
 531 +       return;
 532  }