1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * University Copyright- Copyright (c) 1982, 1986, 1988 31 * The Regents of the University of California 32 * All Rights Reserved 33 * 34 * University Acknowledgment- Portions of this document are derived from 35 * software developed by the University of California, Berkeley, and its 36 * contributors. 37 */ 38 39 /* 40 * This is the new w command which takes advantage of 41 * the /proc interface to gain access to the information 42 * of all the processes currently on the system. 43 * 44 * This program also implements 'uptime'. 45 * 46 * Maintenance note: 47 * 48 * Much of this code is replicated in whodo.c. If you're 49 * fixing bugs here, then you should probably fix 'em there too. 50 */ 51 52 #include <stdio.h> 53 #include <string.h> 54 #include <stdarg.h> 55 #include <stdlib.h> 56 #include <ctype.h> 57 #include <fcntl.h> 58 #include <time.h> 59 #include <errno.h> 60 #include <sys/types.h> 61 #include <utmpx.h> 62 #include <sys/stat.h> 63 #include <dirent.h> 64 #include <procfs.h> /* /proc header file */ 65 #include <locale.h> 66 #include <unistd.h> 67 #include <sys/loadavg.h> 68 #include <limits.h> 69 #include <priv_utils.h> 70 71 /* 72 * utmpx defines wider fields for user and line. For compatibility of output, 73 * we are limiting these to the old maximums in utmp. Define UTMPX_NAMELEN 74 * to use the full lengths. 75 */ 76 #ifndef UTMPX_NAMELEN 77 /* XXX - utmp - fix name length */ 78 #define NMAX (_POSIX_LOGIN_NAME_MAX - 1) 79 #define LMAX 12 80 #else /* UTMPX_NAMELEN */ 81 static struct utmpx dummy; 82 #define NMAX (sizeof (dummy.ut_user)) 83 #define LMAX (sizeof (dummy.ut_line)) 84 #endif /* UTMPX_NAMELEN */ 85 86 #define DIV60(t) ((t+30)/60) /* x/60 rounded */ 87 88 #ifdef ERR 89 #undef ERR 90 #endif 91 #define ERR (-1) 92 93 #define HSIZE 256 /* size of process hash table */ 94 #define PROCDIR "/proc" 95 #define INITPROCESS (pid_t)1 /* init process pid */ 96 #define NONE 'n' /* no state */ 97 #define RUNNING 'r' /* runnable process */ 98 #define ZOMBIE 'z' /* zombie process */ 99 #define VISITED 'v' /* marked node as visited */ 100 #define PRINTF(a) if (printf a < 0) { \ 101 perror((gettext("%s: printf failed"), prog)); \ 102 exit(1); } 103 104 struct uproc { 105 pid_t p_upid; /* process id */ 106 char p_state; /* numeric value of process state */ 107 dev_t p_ttyd; /* controlling tty of process */ 108 time_t p_time; /* seconds of user & system time */ 109 time_t p_ctime; /* seconds of child user & sys time */ 110 int p_igintr; /* 1 = ignores SIGQUIT and SIGINT */ 111 char p_comm[PRARGSZ+1]; /* command */ 112 char p_args[PRARGSZ+1]; /* command line arguments */ 113 struct uproc *p_child, /* first child pointer */ 114 *p_sibling, /* sibling pointer */ 115 *p_pgrpl, /* pgrp link */ 116 *p_link; /* hash table chain pointer */ 117 }; 118 119 /* 120 * define hash table for struct uproc 121 * Hash function uses process id 122 * and the size of the hash table(HSIZE) 123 * to determine process index into the table. 124 */ 125 static struct uproc pr_htbl[HSIZE]; 126 127 static struct uproc *findhash(pid_t); 128 static time_t findidle(char *); 129 static void clnarglist(char *); 130 static void showtotals(struct uproc *); 131 static void calctotals(struct uproc *); 132 static void prttime(time_t, char *); 133 static void prtat(time_t *time); 134 static void checkampm(char *str); 135 136 static char *prog; /* pointer to invocation name */ 137 static int header = 1; /* true if -h flag: don't print heading */ 138 static int lflag = 1; /* set if -l flag; 0 for -s flag: short form */ 139 static char *sel_user; /* login of particular user selected */ 140 static char firstchar; /* first char of name of prog invoked as */ 141 static int login; /* true if invoked as login shell */ 142 static time_t now; /* current time of day */ 143 static time_t uptime; /* time of last reboot & elapsed time since */ 144 static int nusers; /* number of users logged in now */ 145 static time_t idle; /* number of minutes user is idle */ 146 static time_t jobtime; /* total cpu time visible */ 147 static char doing[520]; /* process attached to terminal */ 148 static time_t proctime; /* cpu time of process in doing */ 149 static pid_t curpid, empty; 150 static int add_times; /* boolean: add the cpu times or not */ 151 152 #if SIGQUIT > SIGINT 153 #define ACTSIZE SIGQUIT 154 #else 155 #define ACTSIZE SIGINT 156 #endif 157 158 int 159 main(int argc, char *argv[]) 160 { 161 struct utmpx *ut; 162 struct utmpx *utmpbegin; 163 struct utmpx *utmpend; 164 struct utmpx *utp; 165 struct uproc *up, *parent, *pgrp; 166 struct psinfo info; 167 struct sigaction actinfo[ACTSIZE]; 168 struct pstatus statinfo; 169 size_t size; 170 struct stat sbuf; 171 DIR *dirp; 172 struct dirent *dp; 173 char pname[64]; 174 char *fname; 175 int procfd; 176 char *cp; 177 int i; 178 int days, hrs, mins; 179 int entries; 180 double loadavg[3]; 181 182 /* 183 * This program needs the proc_owner privilege 184 */ 185 (void) __init_suid_priv(PU_CLEARLIMITSET, PRIV_PROC_OWNER, 186 (char *)NULL); 187 188 (void) setlocale(LC_ALL, ""); 189 #if !defined(TEXT_DOMAIN) 190 #define TEXT_DOMAIN "SYS_TEST" 191 #endif 192 (void) textdomain(TEXT_DOMAIN); 193 194 login = (argv[0][0] == '-'); 195 cp = strrchr(argv[0], '/'); 196 firstchar = login ? argv[0][1] : (cp == 0) ? argv[0][0] : cp[1]; 197 prog = argv[0]; 198 199 while (argc > 1) { 200 if (argv[1][0] == '-') { 201 for (i = 1; argv[1][i]; i++) { 202 switch (argv[1][i]) { 203 204 case 'h': 205 header = 0; 206 break; 207 208 case 'l': 209 lflag++; 210 break; 211 case 's': 212 lflag = 0; 213 break; 214 215 case 'u': 216 case 'w': 217 firstchar = argv[1][i]; 218 break; 219 220 default: 221 (void) fprintf(stderr, gettext( 222 "%s: bad flag %s\n"), 223 prog, argv[1]); 224 exit(1); 225 } 226 } 227 } else { 228 if (!isalnum(argv[1][0]) || argc > 2) { 229 (void) fprintf(stderr, gettext( 230 "usage: %s [ -hlsuw ] [ user ]\n"), prog); 231 exit(1); 232 } else 233 sel_user = argv[1]; 234 } 235 argc--; argv++; 236 } 237 238 /* 239 * read the UTMP_FILE (contains information about each logged in user) 240 */ 241 if (stat(UTMPX_FILE, &sbuf) == ERR) { 242 (void) fprintf(stderr, gettext("%s: stat error of %s: %s\n"), 243 prog, UTMPX_FILE, strerror(errno)); 244 exit(1); 245 } 246 entries = sbuf.st_size / sizeof (struct futmpx); 247 size = sizeof (struct utmpx) * entries; 248 if ((ut = malloc(size)) == NULL) { 249 (void) fprintf(stderr, gettext("%s: malloc error of %s: %s\n"), 250 prog, UTMPX_FILE, strerror(errno)); 251 exit(1); 252 } 253 254 (void) utmpxname(UTMPX_FILE); 255 256 utmpbegin = ut; 257 utmpend = (struct utmpx *)((char *)utmpbegin + size); 258 259 setutxent(); 260 while ((ut < utmpend) && ((utp = getutxent()) != NULL)) 261 (void) memcpy(ut++, utp, sizeof (*ut)); 262 endutxent(); 263 264 (void) time(&now); /* get current time */ 265 266 if (header) { /* print a header */ 267 prtat(&now); 268 for (ut = utmpbegin; ut < utmpend; ut++) { 269 if (ut->ut_type == USER_PROCESS) { 270 if (!nonuser(*ut)) 271 nusers++; 272 } else if (ut->ut_type == BOOT_TIME) { 273 uptime = now - ut->ut_xtime; 274 uptime += 30; 275 days = uptime / (60*60*24); 276 uptime %= (60*60*24); 277 hrs = uptime / (60*60); 278 uptime %= (60*60); 279 mins = uptime / 60; 280 281 PRINTF((gettext(" up"))); 282 if (days > 0) 283 PRINTF((gettext( 284 " %d day(s),"), days)); 285 if (hrs > 0 && mins > 0) { 286 PRINTF((" %2d:%02d,", hrs, mins)); 287 } else { 288 if (hrs > 0) 289 PRINTF((gettext( 290 " %d hr(s),"), hrs)); 291 if (mins > 0) 292 PRINTF((gettext( 293 " %d min(s),"), mins)); 294 } 295 } 296 } 297 298 ut = utmpbegin; /* rewind utmp data */ 299 PRINTF((((nusers == 1) ? 300 gettext(" %d user") : gettext(" %d users")), nusers)); 301 /* 302 * Print 1, 5, and 15 minute load averages. 303 */ 304 (void) getloadavg(loadavg, 3); 305 PRINTF((gettext(", load average: %.2f, %.2f, %.2f\n"), 306 loadavg[LOADAVG_1MIN], loadavg[LOADAVG_5MIN], 307 loadavg[LOADAVG_15MIN])); 308 309 if (firstchar == 'u') /* uptime command */ 310 exit(0); 311 312 if (lflag) { 313 PRINTF((dcgettext(NULL, "User tty " 314 "login@ idle JCPU PCPU what\n", LC_TIME))); 315 } else { 316 PRINTF((dcgettext(NULL, 317 "User tty idle what\n", LC_TIME))); 318 } 319 320 if (fflush(stdout) == EOF) { 321 perror((gettext("%s: fflush failed\n"), prog)); 322 exit(1); 323 } 324 } 325 326 /* 327 * loop through /proc, reading info about each process 328 * and build the parent/child tree 329 */ 330 if (!(dirp = opendir(PROCDIR))) { 331 (void) fprintf(stderr, gettext("%s: could not open %s: %s\n"), 332 prog, PROCDIR, strerror(errno)); 333 exit(1); 334 } 335 336 while ((dp = readdir(dirp)) != NULL) { 337 if (dp->d_name[0] == '.') 338 continue; 339 retry: 340 (void) sprintf(pname, "%s/%s/", PROCDIR, dp->d_name); 341 fname = pname + strlen(pname); 342 (void) strcpy(fname, "psinfo"); 343 if ((procfd = open(pname, O_RDONLY)) < 0) 344 continue; 345 if (read(procfd, &info, sizeof (info)) != sizeof (info)) { 346 int err = errno; 347 (void) close(procfd); 348 if (err == EAGAIN) 349 goto retry; 350 if (err != ENOENT) 351 (void) fprintf(stderr, gettext( 352 "%s: read() failed on %s: %s \n"), 353 prog, pname, strerror(err)); 354 continue; 355 } 356 (void) close(procfd); 357 358 up = findhash(info.pr_pid); 359 up->p_ttyd = info.pr_ttydev; 360 up->p_state = (info.pr_nlwp == 0? ZOMBIE : RUNNING); 361 up->p_time = 0; 362 up->p_ctime = 0; 363 up->p_igintr = 0; 364 (void) strncpy(up->p_comm, info.pr_fname, 365 sizeof (info.pr_fname)); 366 up->p_args[0] = 0; 367 368 if (up->p_state != NONE && up->p_state != ZOMBIE) { 369 (void) strcpy(fname, "status"); 370 371 /* now we need the proc_owner privilege */ 372 (void) __priv_bracket(PRIV_ON); 373 374 procfd = open(pname, O_RDONLY); 375 376 /* drop proc_owner privilege after open */ 377 (void) __priv_bracket(PRIV_OFF); 378 379 if (procfd < 0) 380 continue; 381 382 if (read(procfd, &statinfo, sizeof (statinfo)) 383 != sizeof (statinfo)) { 384 int err = errno; 385 (void) close(procfd); 386 if (err == EAGAIN) 387 goto retry; 388 if (err != ENOENT) 389 (void) fprintf(stderr, gettext( 390 "%s: read() failed on %s: %s \n"), 391 prog, pname, strerror(err)); 392 continue; 393 } 394 (void) close(procfd); 395 396 up->p_time = statinfo.pr_utime.tv_sec + 397 statinfo.pr_stime.tv_sec; /* seconds */ 398 up->p_ctime = statinfo.pr_cutime.tv_sec + 399 statinfo.pr_cstime.tv_sec; 400 401 (void) strcpy(fname, "sigact"); 402 403 /* now we need the proc_owner privilege */ 404 (void) __priv_bracket(PRIV_ON); 405 406 procfd = open(pname, O_RDONLY); 407 408 /* drop proc_owner privilege after open */ 409 (void) __priv_bracket(PRIV_OFF); 410 411 if (procfd < 0) 412 continue; 413 414 if (read(procfd, actinfo, sizeof (actinfo)) 415 != sizeof (actinfo)) { 416 int err = errno; 417 (void) close(procfd); 418 if (err == EAGAIN) 419 goto retry; 420 if (err != ENOENT) 421 (void) fprintf(stderr, gettext( 422 "%s: read() failed on %s: %s \n"), 423 prog, pname, strerror(err)); 424 continue; 425 } 426 (void) close(procfd); 427 428 up->p_igintr = 429 actinfo[SIGINT-1].sa_handler == SIG_IGN && 430 actinfo[SIGQUIT-1].sa_handler == SIG_IGN; 431 432 /* 433 * Process args. 434 */ 435 up->p_args[0] = 0; 436 clnarglist(info.pr_psargs); 437 (void) strcat(up->p_args, info.pr_psargs); 438 if (up->p_args[0] == 0 || 439 up->p_args[0] == '-' && up->p_args[1] <= ' ' || 440 up->p_args[0] == '?') { 441 (void) strcat(up->p_args, " ("); 442 (void) strcat(up->p_args, up->p_comm); 443 (void) strcat(up->p_args, ")"); 444 } 445 } 446 447 /* 448 * link pgrp together in case parents go away 449 * Pgrp chain is a single linked list originating 450 * from the pgrp leader to its group member. 451 */ 452 if (info.pr_pgid != info.pr_pid) { /* not pgrp leader */ 453 pgrp = findhash(info.pr_pgid); 454 up->p_pgrpl = pgrp->p_pgrpl; 455 pgrp->p_pgrpl = up; 456 } 457 parent = findhash(info.pr_ppid); 458 459 /* if this is the new member, link it in */ 460 if (parent->p_upid != INITPROCESS) { 461 if (parent->p_child) { 462 up->p_sibling = parent->p_child; 463 up->p_child = 0; 464 } 465 parent->p_child = up; 466 } 467 } 468 469 /* revert to non-privileged user after opening */ 470 (void) __priv_relinquish(); 471 472 (void) closedir(dirp); 473 (void) time(&now); /* get current time */ 474 475 /* 476 * loop through utmpx file, printing process info 477 * about each logged in user 478 */ 479 for (ut = utmpbegin; ut < utmpend; ut++) { 480 if (ut->ut_type != USER_PROCESS) 481 continue; 482 if (sel_user && strncmp(ut->ut_name, sel_user, NMAX) != 0) 483 continue; /* we're looking for somebody else */ 484 485 /* print login name of the user */ 486 PRINTF(("%-*.*s ", NMAX, NMAX, ut->ut_name)); 487 488 /* print tty user is on */ 489 if (lflag) { 490 PRINTF(("%-*.*s", LMAX, LMAX, ut->ut_line)); 491 } else { 492 if (ut->ut_line[0] == 'p' && ut->ut_line[1] == 't' && 493 ut->ut_line[2] == 's' && ut->ut_line[3] == '/') { 494 PRINTF(("%-*.3s", LMAX, &ut->ut_line[4])); 495 } else { 496 PRINTF(("%-*.*s", LMAX, LMAX, ut->ut_line)); 497 } 498 } 499 500 /* print when the user logged in */ 501 if (lflag) { 502 time_t tim = ut->ut_xtime; 503 prtat(&tim); 504 } 505 506 /* print idle time */ 507 idle = findidle(ut->ut_line); 508 if (idle >= 36 * 60) { 509 PRINTF((dcgettext(NULL, "%2ddays ", LC_TIME), 510 (idle + 12 * 60) / (24 * 60))); 511 } else 512 prttime(idle, " "); 513 showtotals(findhash(ut->ut_pid)); 514 } 515 if (fclose(stdout) == EOF) { 516 perror((gettext("%s: fclose failed"), prog)); 517 exit(1); 518 } 519 return (0); 520 } 521 522 /* 523 * Prints the CPU time for all processes & children, 524 * and the cpu time for interesting process, 525 * and what the user is doing. 526 */ 527 static void 528 showtotals(struct uproc *up) 529 { 530 jobtime = 0; 531 proctime = 0; 532 empty = 1; 533 curpid = -1; 534 add_times = 1; 535 536 calctotals(up); 537 538 if (lflag) { 539 /* print CPU time for all processes & children */ 540 /* and need to convert clock ticks to seconds first */ 541 prttime((time_t)jobtime, " "); 542 543 /* print cpu time for interesting process */ 544 /* and need to convert clock ticks to seconds first */ 545 prttime((time_t)proctime, " "); 546 } 547 /* what user is doing, current process */ 548 PRINTF((" %-.32s\n", doing)); 549 } 550 551 /* 552 * This recursive routine descends the process 553 * tree starting from the given process pointer(up). 554 * It used depth-first search strategy and also marked 555 * each node as visited as it traversed down the tree. 556 * It calculates the process time for all processes & 557 * children. It also finds the interesting process 558 * and determines its cpu time and command. 559 */ 560 static void 561 calctotals(struct uproc *up) 562 { 563 struct uproc *zp; 564 565 /* 566 * Once a node has been visited, stop adding cpu times 567 * for its children so they don't get totalled twice. 568 * Still look for the interesting job for this utmp 569 * entry, however. 570 */ 571 if (up->p_state == VISITED) 572 add_times = 0; 573 up->p_state = VISITED; 574 if (up->p_state == NONE || up->p_state == ZOMBIE) 575 return; 576 577 if (empty && !up->p_igintr) { 578 empty = 0; 579 curpid = -1; 580 } 581 582 if (up->p_upid > curpid && (!up->p_igintr || empty)) { 583 curpid = up->p_upid; 584 if (lflag) 585 (void) strcpy(doing, up->p_args); 586 else 587 (void) strcpy(doing, up->p_comm); 588 } 589 590 if (add_times == 1) { 591 jobtime += up->p_time + up->p_ctime; 592 proctime += up->p_time; 593 } 594 595 /* descend for its children */ 596 if (up->p_child) { 597 calctotals(up->p_child); 598 for (zp = up->p_child->p_sibling; zp; zp = zp->p_sibling) 599 calctotals(zp); 600 } 601 } 602 603 /* 604 * Findhash finds the appropriate entry in the process 605 * hash table (pr_htbl) for the given pid in case that 606 * pid exists on the hash chain. It returns back a pointer 607 * to that uproc structure. If this is a new pid, it allocates 608 * a new node, initializes it, links it into the chain (after 609 * head) and returns a structure pointer. 610 */ 611 static struct uproc * 612 findhash(pid_t pid) 613 { 614 struct uproc *up, *tp; 615 616 tp = up = &pr_htbl[pid % HSIZE]; 617 if (up->p_upid == 0) { /* empty slot */ 618 up->p_upid = pid; 619 up->p_state = NONE; 620 up->p_child = up->p_sibling = up->p_pgrpl = up->p_link = 0; 621 return (up); 622 } 623 if (up->p_upid == pid) { /* found in hash table */ 624 return (up); 625 } 626 for (tp = up->p_link; tp; tp = tp->p_link) { /* follow chain */ 627 if (tp->p_upid == pid) 628 return (tp); 629 } 630 tp = malloc(sizeof (*tp)); /* add new node */ 631 if (!tp) { 632 (void) fprintf(stderr, gettext("%s: out of memory!: %s\n"), 633 prog, strerror(errno)); 634 exit(1); 635 } 636 (void) memset(tp, 0, sizeof (*tp)); 637 tp->p_upid = pid; 638 tp->p_state = NONE; 639 tp->p_child = tp->p_sibling = tp->p_pgrpl = 0; 640 tp->p_link = up->p_link; /* insert after head */ 641 up->p_link = tp; 642 return (tp); 643 } 644 645 #define HR (60 * 60) 646 #define DAY (24 * HR) 647 #define MON (30 * DAY) 648 649 /* 650 * prttime prints a time in hours and minutes or minutes and seconds. 651 * The character string tail is printed at the end, obvious 652 * strings to pass are "", " ", or "am". 653 */ 654 static void 655 prttime(time_t tim, char *tail) 656 { 657 if (tim >= 60) { 658 PRINTF((dcgettext(NULL, "%3d:%02d", LC_TIME), 659 (int)tim/60, (int)tim%60)); 660 } else if (tim > 0) { 661 PRINTF((dcgettext(NULL, " %2d", LC_TIME), (int)tim)); 662 } else { 663 PRINTF((" ")); 664 } 665 PRINTF(("%s", tail)); 666 } 667 668 /* 669 * prints a 12 hour time given a pointer to a time of day 670 */ 671 static void 672 prtat(time_t *time) 673 { 674 struct tm *p; 675 676 p = localtime(time); 677 if (now - *time <= 18 * HR) { 678 char timestr[50]; 679 (void) strftime(timestr, sizeof (timestr), 680 dcgettext(NULL, "%l:%M""%p", LC_TIME), p); 681 checkampm(timestr); 682 PRINTF((" %s", timestr)); 683 } else if (now - *time <= 7 * DAY) { 684 char weekdaytime[20]; 685 686 (void) strftime(weekdaytime, sizeof (weekdaytime), 687 dcgettext(NULL, "%a%l%p", LC_TIME), p); 688 checkampm(weekdaytime); 689 PRINTF((" %s", weekdaytime)); 690 } else { 691 char monthtime[20]; 692 693 (void) strftime(monthtime, sizeof (monthtime), 694 dcgettext(NULL, "%e%b%y", LC_TIME), p); 695 PRINTF((" %s", monthtime)); 696 } 697 } 698 699 /* 700 * find & return number of minutes current tty has been idle 701 */ 702 static time_t 703 findidle(char *devname) 704 { 705 struct stat stbuf; 706 time_t lastaction, diff; 707 char ttyname[64]; 708 709 (void) strcpy(ttyname, "/dev/"); 710 (void) strcat(ttyname, devname); 711 if (stat(ttyname, &stbuf) != -1) { 712 lastaction = stbuf.st_atime; 713 diff = now - lastaction; 714 diff = DIV60(diff); 715 if (diff < 0) 716 diff = 0; 717 } else 718 diff = 0; 719 return (diff); 720 } 721 722 /* 723 * given a pointer to the argument string get rid of unsavory characters. 724 */ 725 static void 726 clnarglist(char *arglist) 727 { 728 char *c; 729 int err = 0; 730 731 /* get rid of unsavory characters */ 732 for (c = arglist; *c != NULL; c++) { 733 if ((*c < ' ') || (*c > 0176)) { 734 if (err++ > 5) { 735 *arglist = NULL; 736 break; 737 } 738 *c = '?'; 739 } 740 } 741 } 742 743 /* replaces all occurences of AM/PM with am/pm */ 744 static void 745 checkampm(char *str) 746 { 747 char *ampm; 748 while ((ampm = strstr(str, "AM")) != NULL || 749 (ampm = strstr(str, "PM")) != NULL) { 750 *ampm = tolower(*ampm); 751 *(ampm+1) = tolower(*(ampm+1)); 752 } 753 } 754