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