![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lpstat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / mlp|
Return to lpstat.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / mlp |
1.1 root 1: /******************************************************************************
2: lpstat. MLP line-printer status a'la Unix V.
3: ******************************************************************************/
4:
5: #include "header.h"
6:
7:
8: extern char curr_printer[WORKSTR];
9: extern char curr_device[WORKSTR];
10: extern char curr_backend[WORKSTR];
11:
12:
13: /******************************************************************************
14: Report the name of the system default printer
15: ******************************************************************************/
16:
17: void system_default_printer()
18: {
19: char *c;
20: c = controls( DEFAULT, "");
21:
22: printf("system default destination is: %s\n", c);
23: }
24:
25:
26:
27: /******************************************************************************
28: Report whether the scheduler is running or not
29: ******************************************************************************/
30:
31: void report_scheduler_status()
32: {
33: if ( scheduler_status())
34: printf("scheduler is running\n");
35: else
36: printf("scheduler is not running\n");
37: }
38:
39:
40:
41:
42:
43: /******************************************************************************
44: List the currently printing requests and the pending ones in Unix V style
45: ******************************************************************************/
46:
47: report_request_status()
48: {
49: int n, fd;
50: char *requests, *entries, *name, header[HEADER_SIZE], path[WORKSTR];
51: char user[20], timestr[40], printer[20];
52: long rtime;
53: struct passwd *p;
54:
55: p = getpwuid(getuid());
56:
57: requests = report_printer_status( REQUEST_DISPLAY);
58:
59: entries = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
60: /* This list is a two dimensional */
61: /* array (entries x MAXNAMLEN) */
62: /* Ascending order */
63:
64: for ( n = 0; *(name = (entries+(n * MAXNAMLEN))); n++) {
65: if ( *name == 'r') break;
66:
67: if (strstr( requests, name) == NULL) {
68: sprintf( path, "%s/%s", QUEUE_PATH, name);
69:
70: if ( (fd = open( path, O_RDONLY)) != BAD) {
71: read( fd, header, HEADER_SIZE);
72: close( fd);
73:
74: strcpy( user, headerval( header, H_USER, ""));
75: unpadd( user);
76:
77: if ( (p && !strcmp( user, p->pw_name)) || (getuid(0) == 0)) {
78: strcpy( printer, headerval( header, H_PRINTER, ""));
79: unpadd( printer);
80:
81: strcpy( timestr, headerval( header, H_DSTAMP, ""));
82: rtime = 0L; sscanf( timestr, "%ld", &rtime);
83: strcpy( timestr, ctime(&rtime));
84: timestr[strlen(timestr)-1] = 0;
85:
86: printf( "%s-%s\t\t%c\t%s", user,
87: (name+2), *(name+1), timestr);
88:
89: printf( "\tfor %s\n", printer);
90: }
91: }
92: }
93: }
94:
95: free( entries);
96: }
97:
98:
99:
100:
101:
102: /******************************************************************************
103: List the currently printing requests and the pending ones in MLP style
104: ******************************************************************************/
105:
106: report_mlp_request_status()
107: {
108: int n, fd, printing, val;
109: char *requests, *entries, *name, header[HEADER_SIZE], path[WORKSTR];
110: char user[20], printer[20], title[100], tmp[WORKSTR];
111: long rtime;
112: struct tm *tt;
113:
114: entries = dirlist( QUEUE_PATH, TRUE); /* return sorted spool queue list */
115: /* This list is a two dimensional */
116: /* array (entries x MAXNAMLEN) */
117: /* Ascending order */
118:
119: printf("REQ # S P L #Pgs FL #Cp Date Time Description...\n");
120: printf("----- - - - ---- --- --- -------- ----- -----------------------------------\n");
121:
122: for ( n = 0; *(name = (entries+(n * MAXNAMLEN))); n++) {
123: printing = FALSE;
124:
125: if (strstr( requests, name)) printing = TRUE;
126:
127: sprintf( path, "%s/%s", QUEUE_PATH, name);
128:
129: if ( (fd = open( path, O_RDONLY)) != BAD) {
130: read( fd, header, HEADER_SIZE);
131: close( fd);
132:
133: printf("%-5s ", (name+2)); /* request sequence no. */
134:
135: /* Request Status */
136:
137: if (printing)
138: printf("* "); /* printing now */
139: else
140: if (*name == 'R')
141: printf("P "); /* waiting to print */
142: else
143: if (*name == 'r')
144: printf("Q "); /* held in queue print */
145: else
146: printf("? "); /* don't know the status */
147:
148: printf("%c ", *(name+1)); /* priority */
149:
150: printf("%s ", unpadd( headerval( header, H_LONGEVITY, "")));
151:
152: val = 0;
153: sscanf( unpadd( headerval( header, H_PAGES, "")), "%d", &val);
154: printf("%4d ", val);
155:
156: val = 0;
157: sscanf( unpadd( headerval( header, H_FORMLEN, "")), "%d", &val);
158: printf("%3d ", val);
159:
160: val = 0;
161: sscanf( unpadd( headerval( header, H_COPIES, "")), "%d", &val);
162: printf("%3d ", val);
163:
164:
165: sscanf( unpadd( headerval( header, H_DSTAMP, "")), "%ld", &rtime);
166:
167: tt = localtime( &rtime);
168:
169: printf( "%02d/%02d/%02d ", (tt->tm_mon+1), tt->tm_mday, tt->tm_year);
170: printf( "%02d:%02d ", tt->tm_hour, tt->tm_min);
171:
172: strcpy( user, unpadd( headerval( header, H_USER, "")));
173: strcpy( printer, unpadd( headerval( header, H_PRINTER, "")));
174: strcpy( title, unpadd( headerval( header, H_DESC, "")));
175:
176: sprintf( tmp, "%s -by %s -on %s", title, user, printer);
177:
178: printf("%s\n", tmp);
179: }
180: }
181: }
182:
183:
184:
185:
186: /******************************************************************************
187: Print a list of printers available for routine.
188: ******************************************************************************/
189:
190: list_printers( user)
191: char *user;
192: {
193: char *list;
194:
195: printf("%s ( ", route_request( user));
196:
197: each_printer( E_START);
198:
199: while (*(list = each_printer( E_NEXT)))
200: printf( "%s ", strtok( list, SEP));
201:
202: each_printer( E_END);
203:
204: printf("system display local )\n");
205: }
206:
207:
208:
209:
210:
211:
212: /******************************************************************************
213: Set the printer that the user wants to route to.
214: ******************************************************************************/
215:
216: set_route( user, printer)
217: char *user;
218: char *printer;
219: {
220: FILE *fp;
221: int inlist;
222: char *list, path[WORKSTR];
223:
224: each_printer( E_START);
225:
226: inlist = FALSE;
227:
228: while (*(list = each_printer( E_NEXT)))
229: if (!strcmp( strtok( list, SEP), printer)) inlist = TRUE;
230:
231: each_printer( E_END);
232:
233: if (!strcmp( "local", printer)) inlist = TRUE;
234: if (!strcmp( "display", printer)) inlist = TRUE;
235: if (!strcmp( "system", printer)) inlist = TRUE;
236:
237: if (!inlist) {
238: printf("\007\"%s\" is not a defined printer.\n", printer);
239: return;
240: }
241:
242: sprintf( path, "%s/%s", ROUTE_PATH, user);
243:
244: if ( fp = fopen( path, "w+")) {
245: fprintf( fp, "%s\n", printer);
246: fclose( fp);
247: printf( "%s, your requests will now spool to the \"%s\" printer.\n",
248: user, printer);
249: }
250: }
251:
252:
253:
254:
255: /******************************************************************************
256: Reprioritize the requests
257: ******************************************************************************/
258:
259: void reprioritize_requests( argc, argv)
260: int argc;
261: char *argv[];
262: {
263: int n, m, reqnum, filenum, fd;
264: char *t, *name, prior, oldnam[WORKSTR], newnam[WORKSTR], *head, auser[30];
265: struct passwd *p;
266:
267: p = getpwuid(getuid());
268:
269: prior = argv[1][2];
270:
271: if ( prior < '0') prior = '0';
272: if ( prior > '9') prior = '9';
273:
274:
275: MLP_lock( L_CANCEL);
276:
277: /* Not sure why I want to do this? */
278: /* kill_printing_request( 0, R_CANCEL, CLEAR_ALL); */
279:
280: t = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
281: /* This list is a two dimensional */
282: /* (entries x MAXNAMLEN) */
283: /* Ascending order */
284:
285: head = (char *) calloc( HEADER_SIZE, 1);
286:
287: for (n = 0; *(name = (t+(n * MAXNAMLEN))); n++) {
288:
289: if (sscanf( &name[2], "%d", &filenum) == 1) {
290:
291: for (m = 2; m <= argc; m++) {
292: if (sscanf( argv[m], "%d", &reqnum) == 1) {
293: if ( filenum == reqnum) {
294: sprintf( oldnam, "%s/%s", QUEUE_PATH, name);
295:
296: if ( (fd = open( oldnam, O_RDONLY)) != BAD) {
297: read( fd, head, HEADER_SIZE);
298: close( fd);
299:
300: strcpy( auser, headerval( head, H_USER, ""));
301: unpadd( auser);
302:
303: if (p && !strcmp( auser, p->pw_name) ||
304: (getuid() == 0)) {
305:
306: name[1] = prior;
307: sprintf( newnam, "%s/%s", QUEUE_PATH, name);
308: rename( oldnam, newnam);
309:
310: if ( *name == 'R') {
311: /* make_inactive( name); */
312: kill_printing_request( reqnum, R_CANCEL, CLEAR_ONE);
313: warning( "Request #%d aborted due to a change in priority",
314: reqnum);
315: }
316: }
317: }
318: }
319: }
320: }
321: }
322: }
323:
324: free( head);
325:
326: MLP_unlock( L_CANCEL);
327:
328: free( t);
329: }
330:
331:
332:
333:
334:
335:
336: /******************************************************************************
337: Change the longevity or the printer
338: ******************************************************************************/
339:
340: void adjust_requests( argc, argv, flag)
341: int argc;
342: char *argv[];
343: int flag;
344: {
345: int n, m, reqnum, filenum, fd;
346: char *t, *name, nam[WORKSTR], oper[20], head[HEADER_SIZE], auser[30];
347: struct passwd *p;
348:
349: p = getpwuid(getuid());
350:
351: strcpy( oper, &argv[1][2]);
352:
353: if (flag == A_LIFETIME) {
354: oper[1] = 0;
355: switch (*oper) {
356: case 't':
357: case 'T': *oper = 'T'; break;
358: case 'l':
359: case 'L': *oper = 'L'; break;
360: case 's':
361: case 'S':
362: default: *oper = 'S'; break;
363: }
364: }
365:
366: MLP_lock( L_CANCEL);
367:
368: /* Not sure why I want to do this? */
369: /* kill_printing_request( 0, R_CANCEL, CLEAR_ALL); */
370:
371: t = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
372: /* This list is a two dimensional */
373: /* (entries x MAXNAMLEN) */
374: /* Ascending order */
375:
376: for (n = 0; *(name = (t+(n * MAXNAMLEN))); n++) {
377:
378: if (sscanf( &name[2], "%d", &filenum) == 1) {
379:
380: for (m = 2; m <= argc; m++) {
381: if (sscanf( argv[m], "%d", &reqnum) == 1) {
382:
383: if ( filenum == reqnum) {
384: sprintf( nam, "%s/%s", QUEUE_PATH, name);
385:
386: if ( fd = open( nam, O_RDWR)) {
387: read( fd, head, HEADER_SIZE);
388:
389: strcpy( auser, headerval( head, H_USER, ""));
390: unpadd( auser);
391:
392: if ((p && !strcmp( auser, p->pw_name)) ||
393: (getuid() == 0)) {
394:
395: if ( flag == A_PRINTER)
396: headerval( head, H_PRINTER, oper);
397: else
398: headerval( head, H_LONGEVITY, oper);
399:
400: lseek( fd, 0L, 0);
401:
402: write( fd, head, HEADER_SIZE);
403: close( fd);
404:
405: if ( *name == 'R' && flag == A_PRINTER) {
406: /* make_inactive( name); */
407: kill_printing_request( reqnum, R_CANCEL, CLEAR_ONE);
408:
409: warning( "Request #%d aborted because it was moved to a new printer",
410: reqnum);
411: }
412: }
413: }
414: }
415:
416:
417: }
418: }
419: }
420: }
421:
422: MLP_unlock( L_CANCEL);
423:
424: free( t);
425: }
426:
427:
428:
429:
430:
431:
432:
433: /******************************************************************************
434: Cancel all the requests in the list given. This is a critical section--we
435: cannot allow the despooler to reschedule a request that we just canceled
436: before we are able to put the request in the inactive queue. First we
437: cancel the despooling of the request, if necessary. Then we place the
438: request in the inactive part of the queue. The keyword "all" on the
439: command line will cancel all printing and pending reports.
440: ******************************************************************************/
441:
442: void cancel_all_requests()
443: {
444: int n, val;
445: char *t, *name;
446:
447: MLP_lock( L_CANCEL);
448:
449: kill_printing_request( 0, R_CANCEL, CLEAR_ALL);
450:
451: t = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
452: /* This list is a two dimensional */
453: /* (entries x MAXNAMLEN) */
454: /* Ascending order */
455:
456:
457:
458:
459: for (n = 0; *(name = (t+(n * MAXNAMLEN))); n++)
460: if ( *name == 'R') {
461: if (do_i_own_it()) {
462: make_inactive( name);
463: sscanf( &name[2], "%d", &val);
464: warning("Request #%d has been canceled.", val);
465: printf("#%d canceled\n", val);
466: }
467: }
468:
469: MLP_unlock( L_CANCEL);
470:
471: free( t);
472: }
473:
474:
475:
476:
477: void cancel_requests( argc, argv)
478: int argc;
479: char *argv[];
480: {
481: int n, m, seqnum, Seqnum;
482: char *c, *d, *t, *name, *head;
483:
484: if (!strcmp( argv[1], "all")) {
485: cancel_all_requests();
486: return;
487: }
488:
489:
490: MLP_lock( L_CANCEL);
491:
492:
493: t = dirlist( QUEUE_PATH, FALSE); /* return sorted spool queue list */
494: /* This list is a two dimensional */
495: /* (entries x MAXNAMLEN) */
496: /* Ascending order */
497:
498: head = (char *) calloc( HEADER_SIZE, 1);
499:
500: for ( n = 1; n < argc; n++) {
501:
502: c = argv[n];
503:
504: if ( d = strrchr( c, '-')) c = (d+1);
505:
506: seqnum = 0; sscanf( c, "%d", &seqnum);
507:
508: if ( seqnum > 0) {
509:
510: if (!kill_printing_request( seqnum, R_CANCEL, CLEAR_ONE)) {
511:
512: for (m = 0; *(name = (t+(m * MAXNAMLEN))); m++)
513: if ( *name == 'R') {
514: sscanf( &name[2], "%d", &Seqnum);
515:
516: if ( Seqnum == seqnum) {
517:
518: if (do_i_own_it()) {
519: make_inactive( name);
520: warning("Request #%d has been canceled.", Seqnum);
521: printf("#%d canceled\n", Seqnum);
522: }
523: }
524: }
525: else
526: break;
527: }
528: }
529: }
530:
531: free( head);
532:
533: MLP_unlock( L_CANCEL);
534:
535: free( t);
536: }
537:
538:
539:
540: /*****************************************************************************
541: Print usage message.
542: *****************************************************************************/
543:
544: void do_usage()
545: {
546: printf("\nusages: lpadmin -pprinter [-vdevice] [-mmodel]\n");
547: printf(" lpadmin -ddestination\n");
548: printf(" lpadmin -xdestination\n\n");
549: printf("NOTE: This utility modifies %s\n", CONTROL_PATH);
550: printf(" Models are found in %s\n\n", BACKEND_PATH);
551: }
552:
553:
554:
555:
556: /*****************************************************************************
557: Delete the given destination from the controls file. This routine is in
558: two parts inorder to reuse some of the code.
559: *****************************************************************************/
560:
561: void _delete_destination( dest, newdest, device, backend)
562: char *dest;
563: char *newdest;
564: char *device;
565: char *backend;
566: {
567: FILE *fp, *newfp;
568: char line[128], *t, tmppath[WORKSTR], tmp[WORKSTR];
569:
570: fp = (FILE *) each_printer( E_FILE);
571:
572: sprintf( tmppath, "%s.tmp", CONTROL_PATH);
573:
574: if ( newfp = fopen( tmppath, "w")) {
575:
576: while (fgets( line, sizeof(line), fp)) {
577: strcpy( tmp, line);
578:
579: if (t = strtok( tmp, SEP)) {
580:
581: if (!strcmp( "PRINTER", uppercase( t))) {
582: t = strtok( NULL, SEP);
583: if (strcmp( dest, t))
584: fprintf( newfp, "%s", line);
585: }
586: else
587: fprintf( newfp, "%s", line);
588: }
589: else
590: fprintf( newfp, "%s", line);
591: }
592:
593:
594: if ( *newdest)
595: fprintf( newfp, "printer = %s, %s, %s\n", newdest, device, backend);
596:
597: close( fp); close( newfp);
598:
599: rename( tmppath, CONTROL_PATH);
600:
601: chmod( CONTROL_PATH, 0664);
602: }
603: }
604:
605:
606: void delete_destination( dest)
607: char *dest;
608: {
609: each_printer( E_START);
610: _delete_destination( dest, "", "", "");
611: each_printer( E_UNLOCK);
612: log( "Remove Printer: %s", dest);
613: }
614:
615:
616:
617:
618:
619: /*****************************************************************************
620: Adds a new destination to the controls file. Any current definition by
621: the same name will be overwritten
622: *****************************************************************************/
623:
624: add_destination( printer, device, backend)
625: char *printer;
626: char *device;
627: char *backend;
628: {
629: each_printer( E_START);
630:
631: _delete_destination( printer, printer, device, backend);
632:
633: each_printer( E_UNLOCK);
634:
635: log( "Add Printer: %s, device=%s, backend=%s", printer, device, backend);
636: }
637:
638:
639:
640:
641: /*****************************************************************************
642: Change the system default destination, checking to see if the destination
643: exists first.
644: *****************************************************************************/
645:
646: change_destination( dest)
647: char *dest;
648: {
649: int ok = FALSE;
650: char *list;
651:
652: each_printer( E_START);
653:
654: while (*(list = each_printer( E_NEXT)))
655: if (!strcmp( strtok( list, SEP), dest)) ok = TRUE;
656:
657: each_printer( E_END);
658:
659: if (ok)
660: controls( DEFAULT, dest);
661: else
662: printf("\007Destination \"%s\" does not exist.\n", dest);
663:
664: log( "Change System Default to: %s", dest);
665: }
666:
667:
668:
669:
670: /*****************************************************************************
671: Parse the arguments and figure out what function to do.
672: *****************************************************************************/
673:
674: lpadmin( argc, argv)
675: int argc;
676: char *argv[];
677: {
678: int n, add, del, dest;
679: char printer[20], backend[20], device[129];
680:
681: if ( argc == 1) { do_usage(); exit(0); }
682:
683: strcpy( printer, "main");
684: strcpy( backend, "");
685: strcpy( device, "/dev/null");
686:
687: add = del = dest = FALSE;
688:
689: for ( n = 1; n < argc; n++) {
690: if (!strncmp( argv[n], "-p", 2)) {
691: strncpy( printer, &argv[n][2], sizeof( printer));
692: add = TRUE;
693: }
694: else
695: if (!strncmp( argv[n], "-x", 2)) {
696: strncpy( printer, &argv[n][2], sizeof( printer));
697: del = TRUE;
698: }
699: else
700: if (!strncmp( argv[n], "-d", 2)) {
701: strncpy( printer, &argv[n][2], sizeof( printer));
702: dest = TRUE;
703: }
704: else
705: if (!strncmp( argv[n], "-m", 2))
706: strncpy( backend, &argv[n][2], sizeof( backend));
707: else
708: if (!strncmp( argv[n], "-v", 2))
709: strncpy( device, &argv[n][2], sizeof( device));
710: }
711:
712:
713:
714:
715: if (add) { /* Add a new printer */
716: add_destination( printer, device, backend);
717: exit(0);
718: }
719:
720: if (del) { /* Delete a printer definition */
721: delete_destination( printer);
722: exit(0);
723: }
724:
725: if (dest) { /* Change the system default printer */
726: change_destination( printer);
727: exit(0);
728: }
729: }
730:
731:
732:
733:
734:
735:
736: void main( argc, argv)
737: int argc;
738: char *argv[];
739: {
740: int n;
741: extern char progname[];
742: char user[15], *c;
743:
744: umask(FPERMS);
745:
746: c = basename( argv[0]); if (c) strcpy( progname, c);
747:
748:
749: /********* If program is called "lpadmin" ***********/
750:
751: if (!strcmp( progname, "lpadmin")) {
752: if (getuid() == 0) {
753: lpadmin( argc, argv);
754: wakeup_despooler();
755: }
756: else
757: printf("\007\nSorry, you must be superuser to do this.\n\n");
758:
759: exit(0);
760: }
761:
762:
763: /********* If program is called "cancel" ***********/
764:
765: if (!strcmp( progname, "cancel")) {
766: if (argc == 1)
767: printf("\nusage: cancel request_num1 request_num2 ... request_numN\n\n");
768: else
769: cancel_requests( argc, argv);
770:
771: wakeup_despooler();
772:
773: exit(0);
774: }
775:
776:
777: /********* If program is called "chreq" ***********/
778:
779: if (!strcmp( progname, "chreq")) {
780: if (!strncmp( argv[1], "-p", 2) && argc > 2)
781: reprioritize_requests( argc, argv);
782: else
783: if (!strncmp( argv[1], "-d", 2) && argc > 2)
784: adjust_requests( argc, argv, A_PRINTER);
785: else
786: if (!strncmp( argv[1], "-l", 2) && argc > 2)
787: adjust_requests( argc, argv, A_LIFETIME);
788: else {
789: printf("\nusage: chreq -pNew_priority reqests_num1 request_");
790: printf("num2 ... request_numN\n\n");
791: printf(" -dNew_destination request_num1 request_");
792: printf("num2 ... request_numN\n\n");
793: printf(" -lNew_lifetime request_num1 request_");
794: printf("num2 ... request_numN\n\n");
795: }
796:
797: wakeup_despooler();
798: exit(0);
799: }
800:
801:
802:
803: /********* If program is called "route" ***********/
804:
805: if (!strcmp( progname, "route")) {
806: strcpy( user, "unknown");
807:
808: if ( getlogin())
809: strcpy( user, getlogin());
810:
811: if ( argc == 1) list_printers( user);
812: else
813: if ( argv[1] != NULL)
814: set_route( user, argv[1]);
815:
816: wakeup_despooler();
817: exit(0);
818: }
819:
820:
821: /********* If program is called "lpstat" ***********/
822: if ( argc == 1) report_request_status();
823:
824: for ( n = 1; n < argc; n++) {
825: if (!strcmp( argv[n], "-s")) { /* Summary */
826: report_scheduler_status();
827: system_default_printer();
828: report_printer_status( DEVICE_DISPLAY);
829: }
830: else
831: if (!strcmp( argv[n], "-v")) /* Devices */
832: report_printer_status( DEVICE_DISPLAY);
833: else
834: if (!strcmp( argv[n], "-t")) { /* All */
835: report_scheduler_status();
836: system_default_printer();
837: report_printer_status( DEVICE_DISPLAY);
838: report_printer_status( PRINTER_DISPLAY);
839: report_request_status();
840: }
841: else
842: if (!strcmp( argv[n], "-q")) /* MLP Queue Status */
843: report_mlp_request_status();
844: else
845: if (!strcmp( argv[n], "-r")) /* Scheduler Status */
846: report_scheduler_status();
847: else
848: if (!strcmp( argv[n], "-p")) /* Printer Status */
849: report_printer_status( PRINTER_DISPLAY);
850: else
851: if (!strcmp( argv[n], "-o")) /* Request Status */
852: report_request_status();
853: else
854: if (!strcmp( argv[n], "-d")) /* Default Destination */
855: system_default_printer();
856: }
857:
858: wakeup_despooler();
859: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.