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