Annotation of freem/src/global_dispatch.c, revision 1.4

1.1       snw         1: /*
1.4     ! snw         2:  *   $Id$
1.1       snw         3:  *    global handler dispatch module
                      4:  *
                      5:  *  
1.3       snw         6:  *   Author: Serena Willis <snw@coherent-logic.com>
1.1       snw         7:  *    Copyright (C) 1998 MUG Deutschland
1.4     ! snw         8:  *    Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1       snw         9:  *
                     10:  *
                     11:  *   This file is part of FreeM.
                     12:  *
                     13:  *   FreeM is free software: you can redistribute it and/or modify
                     14:  *   it under the terms of the GNU Affero Public License as published by
                     15:  *   the Free Software Foundation, either version 3 of the License, or
                     16:  *   (at your option) any later version.
                     17:  *
                     18:  *   FreeM is distributed in the hope that it will be useful,
                     19:  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
                     20:  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     21:  *   GNU Affero Public License for more details.
                     22:  *
                     23:  *   You should have received a copy of the GNU Affero Public License
                     24:  *   along with FreeM.  If not, see <https://www.gnu.org/licenses/>.
                     25:  *
1.4     ! snw        26:  *   $Log$
        !            27:  *
        !            28:  * SPDX-FileCopyrightText:  (C) 2025 Coherent Logic Development LLC
        !            29:  * SPDX-License-Identifier: AGPL-3.0-or-later
1.1       snw        30:  **/
                     31: 
                     32: #include <stdlib.h>
                     33: #include <string.h>
                     34: #include <unistd.h>
                     35: #include <ctype.h>
                     36: 
                     37: #include "mpsdef.h"
                     38: #include "mref.h"
                     39: #include "events.h"
                     40: #include "config.h"
                     41: #include "namespace.h"
                     42: #include "transact.h"
                     43: #include "mdebug.h"
                     44: #include "journal.h"
                     45: #include "iftab.h"
                     46: #include "shmmgr.h"
                     47: 
                     48: void (*gbl_u)(short, char *, char *);
                     49: void (*gbl_s)(short, char *, char *);
                     50: 
                     51: void global_set_engine(char ns, char *engine)
                     52: {
                     53:             
                     54:     
                     55:     if ((strcmp (engine, "BUILTIN") != 0) && (strcmp (engine, "BERKELEYDB") != 0)) {
                     56: 
                     57:         if (strcmp (engine, "NICKELBACK") == 0) {
                     58:             char *j;
                     59:             printf ("\r\nERROR:  please go burn your CD collection in fire. Here, have a segfault...\r\n");
                     60: 
                     61:             j[2] = '\201';
                     62:         }
                     63:         
                     64:         printf ("\r\nERROR:  '%s' is not a valid global storage engine\r\n", engine);
                     65:         merr_raise (M38);
                     66:         
                     67:         return;
                     68:         
                     69:     }
                     70: 
                     71:     switch (ns) {
                     72: 
                     73:         case 'u':
                     74:             strcpy (gbl_u_engine, engine);
                     75: 
                     76:             if (strcmp (engine, "BUILTIN") == 0) {
                     77:                 gbl_u = &global_bltin;
                     78:             }
                     79: #if defined(GVH_BDB)    
                     80:             else if (strcmp (engine, "BERKELEYDB") == 0) {
                     81:                 gbl_u = &global_bdb;
                     82:             }
                     83: #endif            
                     84:             else {
                     85:                 fprintf (stderr, "global_set_engine:  invalid global handler '%s' or FreeM built without '%s' global handler support.\r\n", engine, engine);
                     86:                 fprintf (stderr, "global set_engine:  defaulting to 'BUILTIN' global handler for namespace '%s'.\r\n", nsname);
                     87:                 gbl_u = &global_bltin;
                     88:             }
                     89:            
                     90:             break;
                     91: 
                     92:         case 's':
                     93:             strcpy (gbl_s_engine, engine);
                     94: 
                     95:             if (strcmp (engine, "BUILTIN") == 0) {
                     96:                 gbl_s = &global_bltin;
                     97:             }
                     98: #if defined(GVH_BDB)    
                     99:             else if (strcmp (engine, "BERKELEYDB") == 0) {
                    100:                 gbl_s = &global_bdb;
                    101:             }
                    102: #endif
                    103:             else {
                    104:                 fprintf (stderr, "global_set_engine:  invalid global handler '%s' or FreeM built without '%s' global handler support.\r\n", engine, engine);
                    105:                 fprintf (stderr, "global set_engine:  defaulting to 'BUILTIN' global handler for namespace 'SYSTEM'.\r\n");
                    106:                 gbl_s = &global_bltin;
                    107:             }
                    108:             
                    109:             break;
                    110: 
                    111:     }
                    112: 
                    113:     //ssvn_job_update ();
                    114: 
                    115:     merr_raise (OK);
                    116:     return;
                    117:     
                    118: }
                    119: 
                    120: void global (short action, char *key, char *data)
                    121: {
                    122: 
                    123:     int ierr_sav = OK;
                    124: 
                    125:     char *ptr;
                    126:     char name[256];
                    127:     char old_gloplib[PATHLEN];
                    128:     register int i = 0;
                    129:     register int j = 0;
                    130:     register char ch;
                    131: 
                    132:     char *old_ns;
                    133:     char *old_value;
                    134:     char *new_value;
                    135:     char *tk_buf;
                    136:     char *mapk_buf;
                    137:     char *mapd_buf;
                    138:     freem_ref_t *r;
                    139:     short extref_flg;
                    140:     short mapped_flg;
                    141: 
                    142:     /* variables for transaction-in-flight symbol table */
                    143:     iftab *ift; 
                    144:     char tmpd[256];          
                    145: 
                    146:     old_ns = (char *) malloc (STRLEN * sizeof (char));
                    147:     NULLPTRCHK(old_ns,"global");
                    148:     
                    149:     old_value = (char *) malloc (STRLEN * sizeof (char));
                    150:     NULLPTRCHK(old_value,"global");
                    151: 
                    152:     new_value = (char *) malloc (STRLEN * sizeof (char));
                    153:     NULLPTRCHK(new_value,"global");
                    154: 
                    155:     tk_buf = (char *) malloc (STRLEN * sizeof (char));
                    156:     NULLPTRCHK(tk_buf,"global");
                    157: 
                    158:     mapk_buf = (char *) malloc (STRLEN * sizeof (char));
                    159:     NULLPTRCHK(mapk_buf,"global");
                    160: 
                    161:     mapd_buf = (char *) malloc (STRLEN * sizeof (char));
                    162:     NULLPTRCHK(mapd_buf,"global");
                    163:     
                    164:     r = (freem_ref_t *) malloc (sizeof (freem_ref_t));
                    165:     NULLPTRCHK(r,"global");
                    166: 
                    167:     extref_flg = FALSE;
                    168:     mapped_flg = FALSE;
                    169: 
                    170:     ptr = key;
                    171:     if (key[1] != '$') {
                    172:         while ((shm_config->hdr->tp_owner != pid) && (shm_config->hdr->tp_owner != 0)) {
                    173:             sleep (1);
                    174:         }
                    175:     }
                    176:     
                    177:     stcpy (tk_buf, key);
                    178:     
                    179:     if (key[1] != '$') frm_process_alias (key);
                    180: 
                    181:     if (key[1] != '$') {
                    182:         /* process mappings */
                    183:         ierr_sav = OK;
                    184:         
                    185:         while ((ch = *(ptr++)) != DELIM && ch != EOL && i < 256) {
                    186:             name[i++] = ch;
                    187:         }
                    188:         
                    189:         name[i] = '\0';
                    190:         
                    191:         snprintf (mapk_buf, STRLEN - 1, "^$SYSTEM\202MAPPINGS\202GLOBAL\202%s\201", name);
                    192:         global (get_sym, mapk_buf, mapd_buf);
                    193: 
                    194:         stcnv_m2c (mapd_buf);
                    195:         
                    196:         if (merr () == OK) {
                    197:             mapped_flg = TRUE;
                    198:             strncpy (old_ns, nsname, STRLEN - 1);
                    199:             set_namespace (mapd_buf, 0);
                    200:             strncpy (old_gloplib, gloplib, PATHLEN - 1);
                    201:             strncpy (gloplib, glopath, PATHLEN - 1);
                    202:         }
                    203:         else {
                    204:             merr_raise (OK);
                    205:         }
                    206:     }
                    207:         
                    208:     if (dbg_enable_watch && (action == set_sym)) dbg_fire_watch (key);
                    209:     
                    210:     if ((jnl_enabled == TRUE) && (key[1] != '$') && (tp_committing == FALSE)) {
                    211:         switch (action) {
                    212:             
                    213:             case set_sym:
                    214:                 jnl_ent_write (JNLA_SET, key, data);
                    215:                 break;
                    216: 
                    217:             case kill_sym:
                    218:             case killone:
                    219:                 jnl_ent_write (JNLA_KILL, key, data);
                    220:                 break;
                    221:                 
                    222:         }
                    223:     }
                    224: 
                    225:     /* If we are writing to a global in a transaction but not committing it,
                    226:        queue up the operation at the current transaction level.*/
                    227:     if ((tp_level > 0) && (action == set_sym ||
                    228:                            action == kill_sym ||
                    229:                            action == killone ||
                    230:                            action == merge_sym) && (tp_committing == FALSE)) {        
                    231:         
                    232:         if (key[1] != '$') {
                    233:             tp_add_op (FALSE, action, key, data);
                    234: 
                    235:             merr_raise (OK);
                    236:             return;
                    237:         }
                    238:         
                    239:     }
                    240: 
                    241:     /* in a transaction and retrieving */
                    242:     if ((tp_level > 0) && (action == get_sym)) {
                    243: 
                    244:         /* check transactions-in-flight symbol table */
                    245:         ift = iftab_retrieve (key, tmpd);
                    246: 
                    247:         if (ift != NULL) {
                    248: 
                    249:             if (ift->killed == TRUE) {
                    250:                 merr_raise (M7);
                    251:             }
                    252:             else {
                    253:                 stcpy (data, ift->data);
                    254:                 merr_raise (OK);
                    255:             }
                    256: 
                    257:             return;
                    258:         }
                    259: 
                    260:         /* if we got here, the node referenced by "key" has not been
                    261:            modified in the current transaction, so we can proceed to
                    262:            the normal disk block retrieval. */
                    263:     }
                    264: 
                    265:     
                    266:     mref_init (r, MREF_RT_GLOBAL, "^DUMMY");
                    267:     internal_to_mref (r, key);
                    268: 
                    269:     if (rtn_dialect () == D_M77) {
                    270: 
                    271:         for (i = 0; i < r->subscript_count; i++) {
                    272:             for (j = 0; j < strlen (r->subscripts[i]); j++) {
                    273:                 
                    274:                 ch = r->subscripts[i][j];
                    275:                 
                    276:                 if (!isdigit (ch)) {
                    277:                     merr_raise (NOSTAND);
                    278:                     return;
                    279:                 }
                    280:                 
                    281:             }
                    282:         }
                    283:         
                    284:     }
                    285: 
                    286:     
1.2       snw       287:     if (r->name[1] == '|') {
1.1       snw       288: 
                    289:         /* this is an mdc-style extended reference */
                    290:         
                    291:         char old_code[512];
                    292:         char *old_codptr;
                    293:         char newns[256];       
                    294:         register int i = 0;
                    295:         char *nsstart;
                    296:         char *nssave;
                    297:         char ch;
                    298:         char *subprt;
                    299:         extref_flg = TRUE;
                    300: 
                    301:         /* save off current interpreter state (code and codptr)
                    302:            so we can call expr() without losing the plot */        
                    303:         stcpy (old_code, code);
                    304:         old_codptr = codptr;
                    305: 
                    306:         /* save off the current namespace */
                    307:         strncpy (old_ns, nsname, STRLEN - 1);
                    308:                 
                    309:         nsstart = r->name + 2;
                    310:         nssave = nsstart;
                    311: 
                    312:         /* grab everything between the vertical bars */
                    313:         while ((ch = *(nsstart++)) != '|') {
                    314:             newns[i++] = ch;
                    315:         }
                    316: 
                    317:         newns[i] = '\0';
                    318: 
                    319:         /* load up the namespace expression into the code buffer */
                    320:         strcpy (code, newns);
                    321:         strcat (code, " ");        
                    322:         stcnv_c2m (code);
                    323: 
                    324:         /* point the code pointer at the beginning of code */
                    325:         codptr = code;
                    326: 
                    327:         /* parse a string expression */
                    328:         expr (STRING);
                    329: 
                    330:         /* expr (STRING) stores its result in argptr */
                    331:         stcpy (newns, argptr);
                    332:         stcnv_m2c (newns);
                    333: 
                    334:         /* restore interpreter state */
                    335:         stcpy (code, old_code);
                    336:         codptr = old_codptr;
                    337: 
                    338:         /* grab the rest of the gvn */
                    339:         subprt = nssave + i + 1;
                    340:         snprintf (r->name, 255, "^%s", subprt);
                    341: 
                    342:         /* get a fully-formed key */
                    343:         key = mref_to_internal (r);
                    344: 
                    345:         /* switch to the namespace specified in the extended reference */
                    346:         set_namespace (newns, 0);
                    347:         if (merr () > OK) {
                    348:             
                    349:             if (merr () == M26) {
                    350:                 /* if namespace doesn't exist, go back to the
                    351:                    original one and raise M26 */
                    352:                 set_namespace (old_ns, 0);
                    353:                 merr_raise (M26);
                    354:             }
                    355:             
                    356:             return;
                    357:         }
                    358:     }
                    359: 
                    360:     switch (r->name[1]) {
                    361: 
                    362:         case '%':
                    363:         case '$':
                    364:             
                    365:             if ((action % 2) == 0) {
                    366:                 (*gbl_s)(get_sym, tk_buf, old_value);
                    367:                 stcpy (new_value, data);
                    368:                 merr_raise (OK);
                    369:             }
                    370:                       
                    371:             (*gbl_s)(action, key, data);
                    372:             ierr_sav = ierr;
                    373:             break;
                    374: 
                    375:         default:
                    376: 
                    377:             if ((action % 2) == 0) {
                    378:                 (*gbl_u)(get_sym, tk_buf, old_value);
                    379:                 stcpy (new_value, data);
                    380:                 merr_raise (OK);
                    381:             }
                    382:             
                    383:             (*gbl_u)(action, key, data);
                    384:             ierr_sav = ierr;
                    385:             break;
                    386: 
                    387:     }
                    388: 
                    389:     if ((extref_flg == TRUE) || (mapped_flg == TRUE)) {
                    390: 
                    391:         if (mapped_flg == TRUE) {
                    392:             strncpy (gloplib, old_gloplib, PATHLEN - 1);
                    393:         }
                    394: 
                    395:         set_namespace (old_ns, 0);
                    396: 
                    397:     }
                    398:     
                    399:     if (evt_async_enabled && r->reftype == MREF_RT_GLOBAL) {
                    400:         char an[20];
                    401:         char ev_id[512];
                    402: 
                    403:         char *k_buf = (char *) malloc (STRLEN * sizeof (char));
                    404:         char *d_buf = (char *) malloc (STRLEN * sizeof (char));
                    405:         NULLPTRCHK(k_buf,"global");
                    406:         NULLPTRCHK(d_buf,"global");
                    407: 
                    408:         mref_to_external (r, d_buf);
                    409:         stcnv_c2m (d_buf);
                    410:         
                    411:         switch (action) {
                    412:             case set_sym:
                    413:                 sprintf (an, "SET");
                    414:                 break;
                    415:             case kill_sym:
                    416:             case kill_all:
                    417:             case killexcl:
                    418:             case killone:
                    419:                 sprintf (an, "KILL");
                    420:                 break;
                    421:             case get_sym:
                    422:                 sprintf (an, "GET");
                    423:                 break;
                    424:             case dat:
                    425:                 sprintf (an, "DATA");
                    426:                 break;
                    427:             case fra_order:
                    428:                 sprintf (an, "ORDER");
                    429:                 break;
                    430:             case fra_query:
                    431:             case bigquery:
                    432:                 sprintf (an, "QUERY");
                    433:                 break;
                    434:             case getinc:
                    435:                 sprintf (an, "INCREMENT");
                    436:                 break;
                    437:             case getnext:
                    438:                 sprintf (an, "NEXT");
                    439:                 break;
                    440:             case zdata:
                    441:                 sprintf (an, "ZDATA");
                    442:                 break;
                    443:         }
                    444: 
                    445:         /* NEW ^$EVENT */
                    446:         symtab (new_sym, "^$EVENT\201", "\201");
                    447:         
                    448:         /* populate ^$EVENT("GLVN") with the key */
                    449:         snprintf (k_buf, STRLEN - 1, "^$EVENT\202GLOBAL\201");
                    450:         symtab (set_sym, k_buf, d_buf);
                    451: 
                    452:         if ((action % 2) == 0) {
                    453: 
                    454:             snprintf (k_buf, STRLEN - 1, "^$EVENT\202OLD_VALUE\201");
                    455:             symtab (set_sym, k_buf, old_value);
                    456: 
                    457:             snprintf (k_buf, STRLEN - 1, "^$EVENT\202NEW_VALUE\201");
                    458:             symtab (set_sym, k_buf, new_value);
                    459: 
                    460:         }
                    461:         
                    462:         sprintf (ev_id, "%s:%s", an, r->name);
                    463:         evt_enqueue (ev_id, EVT_CLS_TRIGGER, 0);
                    464: 
                    465:         free (k_buf);
                    466:         free (d_buf);
                    467:     }  
                    468:     
                    469:     free (old_value);
                    470:     free (new_value);
                    471:     free (r);
                    472:     free (tk_buf);
                    473:     free (old_ns);
                    474:     free (mapk_buf);
                    475:     free (mapd_buf);
                    476:     
                    477:     merr_raise (ierr_sav);
                    478:     
                    479: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>