← Back to branch summary

~m-grant-prg/swoc/focal-trunk

« back to all changes in this revision

Viewing changes to src/prg/c/src/srv-lib/libswocserver/optionproc.c

  • Committer: Mark Grant
  • Date: 2022-06-25 15:36:11 UTC
  • mfrom: (1.1.10)
  • Revision ID: m.grant.prg@gmail.com-20220625153611-h6r8erhf0lf9rtwe
Merge new upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/prg/c/src/srv-lib/libswocserver/optionproc.c
3
3
 *
4
4
 * Functions to process server lock flag options.
5
5
 *
6
 
 * @author Copyright (C) 2016-2019, 2021  Mark Grant
 
6
 * @author Copyright (C) 2016-2019, 2021, 2022  Mark Grant
7
7
 *
8
8
 * Released under the GPLv3 only.\n
9
9
 * SPDX-License-Identifier: GPL-3.0-only
10
10
 *
11
 
 * @version _v1.1.14 ==== 08/12/2021_
 
11
 * @version _v1.1.16 ==== 11/06/2022_
12
12
 */
13
13
 
14
14
/* **********************************************************************
65
65
 *                              for terminating nul.                    *
66
66
 * 10/10/2021   MG      1.1.13  Use newly internalised common header.   *
67
67
 * 08/12/2021   MG      1.1.14  Tighten SPDX tag.                       *
 
68
 * 05/04/2022   MG      1.1.15  Improve error handling consistency.     *
 
69
 * 11/06/2022   MG      1.1.16  Correct size of locks_held for sprintf. *
 
70
 *                              Replace sprintf with safer snprintf.    *
68
71
 *                                                                      *
69
72
 ************************************************************************
70
73
 */
93
96
        #define __bool_true_false_are_defined 1
94
97
#endif
95
98
 
 
99
#include <libmgec.h>
96
100
#include <libswoccommon.h>
97
101
#include <libswocserver.h>
98
102
#include <mge-errno.h>
102
106
 * Holds the number of clients currently holding locks during sws_server_wait().
103
107
 * This value can be accessed in a handler if a signal is received.
104
108
 */
105
 
char locks_held[11] = "0";
 
109
char locks_held[12] = "0";
106
110
 
107
111
/**
108
112
 * Display clients with active locks to stdout.
109
113
 * On error mge_errno is set.
110
 
 * @return The number of clients with locks or -1 on error.
 
114
 * @return The number of clients with locks or < zero on error.
111
115
 */
112
116
int sws_show_status(void)
113
117
{
144
148
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
145
149
                       msg->message);
146
150
                clear_msg(msg, ';', ',');
147
 
                return -1;
 
151
                return -mge_errno;
148
152
        }
149
153
 
150
154
        for (i = 3; i < msg->argc; i += 2) {
163
167
/**
164
168
 * Display status of server blocking.
165
169
 * On error mge_errno is set.
166
 
 * @return 0 on success, non-zero on failure.
 
170
 * @return 0 on success, < zero on failure.
167
171
 */
168
172
int sws_show_block_status(void)
169
173
{
198
202
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
199
203
                       msg->message);
200
204
                clear_msg(msg, ';', ',');
201
 
                return -1;
 
205
                return -mge_errno;
202
206
        }
203
207
 
204
208
        if (strcmp(msg->argv[3], "0"))
214
218
/**
215
219
 * Request server blocking.
216
220
 * On error mge_errno is set.
217
 
 * @return 0 on success, non-zero on failure.
 
221
 * @return 0 on success, < zero on failure.
218
222
 */
219
223
int sws_srv_block(void)
220
224
{
249
253
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
250
254
                       msg->message);
251
255
                clear_msg(msg, ';', ',');
252
 
                return -1;
 
256
                return -mge_errno;
253
257
        }
254
258
 
255
259
        syslog((int)(LOG_USER | LOG_NOTICE), "Server is blocked.");
262
266
/**
263
267
 * Request removal of server blocking.
264
268
 * On error mge_errno is set.
265
 
 * @return 0 on success, non-zero on failure.
 
269
 * @return 0 on success, < zero on failure.
266
270
 */
267
271
int sws_srv_unblock(void)
268
272
{
297
301
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
298
302
                       msg->message);
299
303
                clear_msg(msg, ';', ',');
300
 
                return -1;
 
304
                return -mge_errno;
301
305
        }
302
306
 
303
307
        syslog((int)(LOG_USER | LOG_NOTICE), "Server is unblocked.");
310
314
/**
311
315
 * Display list of blocked clients to stdout.
312
316
 * On error mge_errno is set.
313
 
 * @return The number of blocked or -1 on error.
 
317
 * @return The number of blocked or < zero on error.
314
318
 */
315
319
int sws_show_cli_blocklist(void)
316
320
{
347
351
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
348
352
                       msg->message);
349
353
                clear_msg(msg, ';', ',');
350
 
                return -1;
 
354
                return -mge_errno;
351
355
        }
352
356
 
353
357
        for (i = 3; i < msg->argc; i++) {
365
369
/**
366
370
 * Wait until no client locks remain.
367
371
 * On error mge_errno is set.
368
 
 * @return 0 on success, non-zero on failure.
 
372
 * @return 0 on success, < zero on failure.
369
373
 */
370
374
int sws_server_wait(void)
371
375
{
407
411
                               "- %s",
408
412
                               msg->message);
409
413
                        clear_msg(msg, ';', ',');
410
 
                        return mge_errno;
 
414
                        return -mge_errno;
411
415
                }
412
416
                if (msg->argc > 3)
413
 
                        sprintf(locks_held, "%i", ((msg->argc - 3) / 2));
 
417
                        snprintf(locks_held, ARRAY_SIZE(locks_held), "%i",
 
418
                                 ((msg->argc - 3) / 2));
414
419
                empty = strcmp(msg->message, "swocserverd,status,ok;");
415
420
                clear_msg(msg, ';', ',');
416
421
        } while (empty);
425
430
 * Remove a lock.
426
431
 * On error mge_errno is set.
427
432
 * @param lockname Client whose lock is to be removed.
428
 
 * @return 0 on success, non-zero on failure.
 
433
 * @return 0 on success, < zero on failure.
429
434
 */
430
435
int sws_release(char *lockname)
431
436
{
437
442
        struct mgemessage msg1 = MGEMESSAGE_INIT(';', ',');
438
443
        struct mgemessage *msg = &msg1;
439
444
 
440
 
        sprintf(out_msg, "swocserver,release,%s;", lockname);
 
445
        snprintf(out_msg, ARRAY_SIZE(out_msg), "swocserver,release,%s;",
 
446
                 lockname);
441
447
        om_length = strlen(out_msg);
442
448
 
443
449
        prg_err = swcom_validate_config();
463
469
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
464
470
                       msg->message);
465
471
                clear_msg(msg, ';', ',');
466
 
                return mge_errno;
 
472
                return -mge_errno;
467
473
        }
468
474
 
469
475
        syslog((int)(LOG_USER | LOG_NOTICE),
480
486
 * Set a client to blocked.
481
487
 * On error mge_errno is set.
482
488
 * @param blockname Client to block.
483
 
 * @return 0 on success, non-zero on failure.
 
489
 * @return 0 on success, < zero on failure.
484
490
 */
485
491
int sws_cli_block(char *blockname)
486
492
{
492
498
        struct mgemessage msg1 = MGEMESSAGE_INIT(';', ',');
493
499
        struct mgemessage *msg = &msg1;
494
500
 
495
 
        sprintf(out_msg, "swocserver,block,%s;", blockname);
 
501
        snprintf(out_msg, ARRAY_SIZE(out_msg), "swocserver,block,%s;",
 
502
                 blockname);
496
503
        om_length = strlen(out_msg);
497
504
 
498
505
        prg_err = swcom_validate_config();
518
525
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
519
526
                       msg->message);
520
527
                clear_msg(msg, ';', ',');
521
 
                return mge_errno;
 
528
                return -mge_errno;
522
529
        }
523
530
 
524
531
        syslog((int)(LOG_USER | LOG_NOTICE), "Client %s blocked.", blockname);
532
539
 * Unblock a client block.
533
540
 * On error mge_errno is set.
534
541
 * @param blockname Client to unblock.
535
 
 * @return 0 on success, non-zero on failure.
 
542
 * @return 0 on success, < zero on failure.
536
543
 */
537
544
int sws_cli_unblock(char *blockname)
538
545
{
544
551
        struct mgemessage msg1 = MGEMESSAGE_INIT(';', ',');
545
552
        struct mgemessage *msg = &msg1;
546
553
 
547
 
        sprintf(out_msg, "swocserver,unblock,%s;", blockname);
 
554
        snprintf(out_msg, ARRAY_SIZE(out_msg), "swocserver,unblock,%s;",
 
555
                 blockname);
548
556
        om_length = strlen(out_msg);
549
557
 
550
558
        prg_err = swcom_validate_config();
570
578
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
571
579
                       msg->message);
572
580
                clear_msg(msg, ';', ',');
573
 
                return mge_errno;
 
581
                return -mge_errno;
574
582
        }
575
583
 
576
584
        syslog((int)(LOG_USER | LOG_NOTICE), "Client %s unblocked.", blockname);
584
592
 * Terminate the daemon.
585
593
 * Send a message to the daemon asking it to terminate.
586
594
 * On error mge_errno is set.
587
 
 * @return 0 on success, non-zero on failure.
 
595
 * @return 0 on success, < zero on failure.
588
596
 */
589
597
int sws_end_daemon(void)
590
598
{
619
627
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
620
628
                       msg->message);
621
629
                clear_msg(msg, ';', ',');
622
 
                return mge_errno;
 
630
                return -mge_errno;
623
631
        }
624
632
 
625
633
        syslog((int)(LOG_USER | LOG_NOTICE), "Request to end daemon "
634
642
 * Request the daemon to reload the config file.
635
643
 * Send a message to the daemon asking it to reload it's configuration file.
636
644
 * On error mge_errno is set.
637
 
 * @return 0 on success, non-zero on failure.
 
645
 * @return 0 on success, < zero on failure.
638
646
 */
639
647
int sws_reload_config(void)
640
648
{
669
677
                syslog((int)(LOG_USER | LOG_NOTICE), "Invalid message - %s",
670
678
                       msg->message);
671
679
                clear_msg(msg, ';', ',');
672
 
                return mge_errno;
 
680
                return -mge_errno;
673
681
        }
674
682
 
675
683
        syslog((int)(LOG_USER | LOG_NOTICE), "Config file reloaded.");
678
686
 
679
687
        return 0;
680
688
}
681