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>
![[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