/[LeafOK_CVS]/lbbs/src/menu.c
ViewVC logotype

Diff of /lbbs/src/menu.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.38 by sysadm, Tue May 13 07:28:51 2025 UTC Revision 1.47 by sysadm, Sun May 18 08:53:21 2025 UTC
# Line 27  Line 27 
27  #include <stdio.h>  #include <stdio.h>
28  #include <ctype.h>  #include <ctype.h>
29  #include <stdlib.h>  #include <stdlib.h>
30    #include <errno.h>
31    #include <unistd.h>
32    #include <sys/shm.h>
33    #include <sys/ipc.h>
34    
35  #define MENU_SCREEN_PATH_PREFIX "var/MENU_SCR_"  #define MENU_SCREEN_PATH_PREFIX "var/MENU_SCR_"
36  #define MENU_CONF_DELIM_WITH_SPACE " ,\t\r\n"  #define MENU_CONF_DELIM_WITH_SPACE " ,\t\r\n"
37  #define MENU_CONF_DELIM_WITHOUT_SPACE "\r\n"  #define MENU_CONF_DELIM_WITHOUT_SPACE "\r\n"
38    
39  MENU_SET bbs_menu;  #define MENU_SET_RESERVED_LENGTH (sizeof(int16_t) * 4)
40    
41    MENU_SET *p_bbs_menu;
42    
43  int load_menu(MENU_SET *p_menu_set, const char *conf_file)  int load_menu(MENU_SET *p_menu_set, const char *conf_file)
44  {  {
45          FILE *fin, *fout;          FILE *fin;
46          int fin_line = 0;          int fin_line = 0;
         int i = 0;  
         int j = 0;  
47          char buffer[LINE_BUFFER_LEN];          char buffer[LINE_BUFFER_LEN];
48          char temp[LINE_BUFFER_LEN];          char temp[LINE_BUFFER_LEN];
         char screen_filename[FILE_PATH_LEN];  
49          char *p = NULL;          char *p = NULL;
50          char *q = NULL;          char *q = NULL;
51          char *saveptr = NULL;          char *saveptr = NULL;
52          MENU *p_menu = NULL;          MENU *p_menu = NULL;
53          MENU_ITEM *p_item = NULL;          MENU_ITEM *p_menu_item = NULL;
54            MENU_SCREEN *p_screen = NULL;
55            MENU_ID menu_id;
56            MENU_ITEM_ID menu_item_id;
57            MENU_SCREEN_ID screen_id;
58            int proj_id;
59            key_t key;
60            size_t size;
61    
62            // Use trie_dict to search menu_id by menu name
63            p_menu_set->p_menu_name_dict = trie_dict_create();
64            if (p_menu_set->p_menu_name_dict == NULL)
65            {
66                    log_error("trie_dict_create() error\n");
67                    return -3;
68            }
69    
70          p_menu_set->menu_count = 0;          // Use trie_dict to search screen_id by menu screen name
71            p_menu_set->p_menu_screen_dict = trie_dict_create();
72            if (p_menu_set->p_menu_screen_dict == NULL)
73            {
74                    log_error("trie_dict_create() error\n");
75                    return -3;
76            }
77    
78          if ((fin = fopen(conf_file, "r")) == NULL)          if ((fin = fopen(conf_file, "r")) == NULL)
79          {          {
# Line 57  int load_menu(MENU_SET *p_menu_set, cons Line 81  int load_menu(MENU_SET *p_menu_set, cons
81                  return -2;                  return -2;
82          }          }
83    
84          strncpy(p_menu_set->conf_file, conf_file, sizeof(p_menu_set->conf_file) - 1);          // Allocate shared memory
85          p_menu_set->conf_file[sizeof(p_menu_set->conf_file) - 1] = '\0';          proj_id = (int)(time(NULL) % getpid());
86            key = ftok(conf_file, proj_id);
87            if (key == -1)
88            {
89                    log_error("ftok(%s %d) error (%d)\n", conf_file, proj_id, errno);
90                    return -2;
91            }
92    
93            size = MENU_SET_RESERVED_LENGTH +
94                       sizeof(MENU) * MAX_MENUS +
95                       sizeof(MENU_ITEM) * MAX_MENUITEMS +
96                       sizeof(MENU_SCREEN) * MAX_MENUS +
97                       MAX_MENU_SCR_BUF_LENGTH * MAX_MENUS;
98            p_menu_set->shmid = shmget(key, size, IPC_CREAT | IPC_EXCL | 0600);
99            if (p_menu_set->shmid == -1)
100            {
101                    log_error("shmget(size = %d) error (%d)\n", size, errno);
102                    return -3;
103            }
104            p_menu_set->p_reserved = shmat(p_menu_set->shmid, NULL, 0);
105            if (p_menu_set->p_reserved == (void *)-1)
106            {
107                    log_error("shmat() error (%d)\n", errno);
108                    return -3;
109            }
110            p_menu_set->p_menu_pool = p_menu_set->p_reserved + MENU_SET_RESERVED_LENGTH;
111            p_menu_set->p_menu_item_pool = p_menu_set->p_menu_pool + sizeof(MENU) * MAX_MENUS;
112            p_menu_set->p_menu_screen_pool = p_menu_set->p_menu_item_pool + sizeof(MENU_ITEM) * MAX_MENUITEMS;
113            p_menu_set->p_menu_screen_buf = p_menu_set->p_menu_screen_pool + sizeof(MENU_SCREEN) * MAX_MENUS;
114            p_menu_set->p_menu_screen_buf_free = p_menu_set->p_menu_screen_buf;
115    
116            p_menu_set->menu_count = 0;
117            p_menu_set->menu_item_count = 0;
118            p_menu_set->menu_screen_count = 0;
119            p_menu_set->choose_step = 0;
120            p_menu_set->menu_id_path[0] = 0;
121    
122          while (fgets(buffer, sizeof(buffer), fin))          while (fgets(buffer, sizeof(buffer), fin))
123          {          {
# Line 86  int load_menu(MENU_SET *p_menu_set, cons Line 145  int load_menu(MENU_SET *p_menu_set, cons
145                                          log_error("Incomplete menu definition in menu config line %d\n", fin_line);                                          log_error("Incomplete menu definition in menu config line %d\n", fin_line);
146                                          return -1;                                          return -1;
147                                  }                                  }
148                                  p_menu = (MENU *)malloc(sizeof(MENU));  
149                                  if (p_menu == NULL)                                  if (p_menu_set->menu_count >= MAX_MENUS)
150                                  {                                  {
151                                          log_error("Unable to allocate memory for menu\n");                                          log_error("Menu count (%d) exceed limit (%d)\n", p_menu_set->menu_count, MAX_MENUS);
152                                          return -3;                                          return -3;
153                                  }                                  }
154                                  p_menu_set->p_menu[i] = p_menu;                                  menu_id = (MENU_ID)p_menu_set->menu_count;
155                                  i++;                                  p_menu_set->menu_count++;
156                                  p_menu_set->menu_count = i;  
157                                    p_menu = get_menu_by_id(p_menu_set, menu_id);
158    
                                 j = 0; // Menu item counter  
159                                  p_menu->item_count = 0;                                  p_menu->item_count = 0;
                                 p_menu->item_cur_pos = 0;  
160                                  p_menu->title.show = 0;                                  p_menu->title.show = 0;
161                                  p_menu->screen.show = 0;                                  p_menu->screen_show = 0;
162    
163                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
164                                  if (q == NULL)                                  if (q == NULL)
# Line 127  int load_menu(MENU_SET *p_menu_set, cons Line 185  int load_menu(MENU_SET *p_menu_set, cons
185                                  strncpy(p_menu->name, p, sizeof(p_menu->name) - 1);                                  strncpy(p_menu->name, p, sizeof(p_menu->name) - 1);
186                                  p_menu->name[sizeof(p_menu->name) - 1] = '\0';                                  p_menu->name[sizeof(p_menu->name) - 1] = '\0';
187    
188                                    if (trie_dict_set(p_menu_set->p_menu_name_dict, p_menu->name, (int64_t)menu_id) != 1)
189                                    {
190                                            log_error("Error set menu dict [%s]\n", p_menu->name);
191                                    }
192    
193                                  // Check syntax                                  // Check syntax
194                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
195                                  if (q != NULL)                                  if (q != NULL)
# Line 158  int load_menu(MENU_SET *p_menu_set, cons Line 221  int load_menu(MENU_SET *p_menu_set, cons
221                                          else if (*p == '!' || *p == '@')                                          else if (*p == '!' || *p == '@')
222                                          {                                          {
223                                                  // BEGIN of menu item                                                  // BEGIN of menu item
224                                                  p_item = (MENU_ITEM *)malloc(sizeof(MENU_ITEM));                                                  if (p_menu->item_count >= MAX_ITEMS_PER_MENU)
                                                 if (p_item == NULL)  
225                                                  {                                                  {
226                                                          log_error("Unable to allocate memory for menu item\n");                                                          log_error("Menuitem count per menu (%d) exceed limit (%d)\n", p_menu->item_count, MAX_ITEMS_PER_MENU);
227                                                            return -1;
228                                                    }
229                                                    if (p_menu_set->menu_item_count >= MAX_MENUITEMS)
230                                                    {
231                                                            log_error("Menuitem count (%d) exceed limit (%d)\n", p_menu_set->menu_item_count, MAX_MENUITEMS);
232                                                          return -3;                                                          return -3;
233                                                  }                                                  }
234                                                  p_menu->items[j] = p_item;                                                  menu_item_id = (MENU_ITEM_ID)p_menu_set->menu_item_count;
235                                                  j++;                                                  p_menu_set->menu_item_count++;
236                                                  p_menu->item_count = j;  
237                                                    p_menu->items[p_menu->item_count] = menu_item_id;
238                                                    p_menu->item_count++;
239    
240                                                  p_item->submenu = (*p == '!' ? 1 : 0);                                                  p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
241    
242                                                    p_menu_item->submenu = (*p == '!' ? 1 : 0);
243    
244                                                  // Menu item action                                                  // Menu item action
245                                                  p++;                                                  p++;
# Line 190  int load_menu(MENU_SET *p_menu_set, cons Line 261  int load_menu(MENU_SET *p_menu_set, cons
261                                                          }                                                          }
262                                                  }                                                  }
263    
264                                                  if (q - p > sizeof(p_item->action) - 1)                                                  if (q - p > sizeof(p_menu_item->action) - 1)
265                                                  {                                                  {
266                                                          log_error("Too longer menu action in menu config line %d\n", fin_line);                                                          log_error("Too longer menu action in menu config line %d\n", fin_line);
267                                                          return -1;                                                          return -1;
268                                                  }                                                  }
269                                                  strncpy(p_item->action, p, sizeof(p_item->action) - 1);                                                  strncpy(p_menu_item->action, p, sizeof(p_menu_item->action) - 1);
270                                                  p_item->action[sizeof(p_item->action) - 1] = '\0';                                                  p_menu_item->action[sizeof(p_menu_item->action) - 1] = '\0';
271    
272                                                  // Menu item row                                                  // Menu item row
273                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 215  int load_menu(MENU_SET *p_menu_set, cons Line 286  int load_menu(MENU_SET *p_menu_set, cons
286                                                          log_error("Error menu item row in menu config line %d\n", fin_line);                                                          log_error("Error menu item row in menu config line %d\n", fin_line);
287                                                          return -1;                                                          return -1;
288                                                  }                                                  }
289                                                  p_item->row = atoi(p);                                                  p_menu_item->row = (int16_t)atoi(p);
290    
291                                                  // Menu item col                                                  // Menu item col
292                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 234  int load_menu(MENU_SET *p_menu_set, cons Line 305  int load_menu(MENU_SET *p_menu_set, cons
305                                                          log_error("Error menu item col in menu config line %d\n", fin_line);                                                          log_error("Error menu item col in menu config line %d\n", fin_line);
306                                                          return -1;                                                          return -1;
307                                                  }                                                  }
308                                                  p_item->col = atoi(p);                                                  p_menu_item->col = (int16_t)atoi(p);
309    
310                                                  // Menu item priv                                                  // Menu item priv
311                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 253  int load_menu(MENU_SET *p_menu_set, cons Line 324  int load_menu(MENU_SET *p_menu_set, cons
324                                                          log_error("Error menu item priv in menu config line %d\n", fin_line);                                                          log_error("Error menu item priv in menu config line %d\n", fin_line);
325                                                          return -1;                                                          return -1;
326                                                  }                                                  }
327                                                  p_item->priv = atoi(p);                                                  p_menu_item->priv = atoi(p);
328    
329                                                  // Menu item level                                                  // Menu item level
330                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 272  int load_menu(MENU_SET *p_menu_set, cons Line 343  int load_menu(MENU_SET *p_menu_set, cons
343                                                          log_error("Error menu item level in menu config line %d\n", fin_line);                                                          log_error("Error menu item level in menu config line %d\n", fin_line);
344                                                          return -1;                                                          return -1;
345                                                  }                                                  }
346                                                  p_item->level = atoi(p);                                                  p_menu_item->level = atoi(p);
347    
348                                                  // Menu item name                                                  // Menu item name
349                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 294  int load_menu(MENU_SET *p_menu_set, cons Line 365  int load_menu(MENU_SET *p_menu_set, cons
365                                                  }                                                  }
366                                                  *q = '\0';                                                  *q = '\0';
367    
368                                                  if (q - p > sizeof(p_item->name) - 1)                                                  if (q - p > sizeof(p_menu_item->name) - 1)
369                                                  {                                                  {
370                                                          log_error("Too longer menu name in menu config line %d\n", fin_line);                                                          log_error("Too longer menu name in menu config line %d\n", fin_line);
371                                                          return -1;                                                          return -1;
372                                                  }                                                  }
373                                                  strncpy(p_item->name, p, sizeof(p_item->name) - 1);                                                  strncpy(p_menu_item->name, p, sizeof(p_menu_item->name) - 1);
374                                                  p_item->name[sizeof(p_item->name) - 1] = '\0';                                                  p_menu_item->name[sizeof(p_menu_item->name) - 1] = '\0';
375    
376                                                  // Menu item text                                                  // Menu item text
377                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITHOUT_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITHOUT_SPACE, &saveptr);
# Line 322  int load_menu(MENU_SET *p_menu_set, cons Line 393  int load_menu(MENU_SET *p_menu_set, cons
393                                                  }                                                  }
394                                                  *q = '\0';                                                  *q = '\0';
395    
396                                                  if (q - p > sizeof(p_item->text) - 1)                                                  if (q - p > sizeof(p_menu_item->text) - 1)
397                                                  {                                                  {
398                                                          log_error("Too longer menu item text in menu config line %d\n", fin_line);                                                          log_error("Too longer menu item text in menu config line %d\n", fin_line);
399                                                          return -1;                                                          return -1;
400                                                  }                                                  }
401                                                  strncpy(p_item->text, p, sizeof(p_item->text) - 1);                                                  strncpy(p_menu_item->text, p, sizeof(p_menu_item->text) - 1);
402                                                  p_item->text[sizeof(p_item->text) - 1] = '\0';                                                  p_menu_item->text[sizeof(p_menu_item->text) - 1] = '\0';
403    
404                                                  // Check syntax                                                  // Check syntax
405                                                  q = strtok_r(q + 1, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(q + 1, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 359  int load_menu(MENU_SET *p_menu_set, cons Line 430  int load_menu(MENU_SET *p_menu_set, cons
430                                                          log_error("Error menu title row in menu config line %d\n", fin_line);                                                          log_error("Error menu title row in menu config line %d\n", fin_line);
431                                                          return -1;                                                          return -1;
432                                                  }                                                  }
433                                                  p_menu->title.row = atoi(p);                                                  p_menu->title.row = (int16_t)atoi(p);
434    
435                                                  // Menu title col                                                  // Menu title col
436                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 378  int load_menu(MENU_SET *p_menu_set, cons Line 449  int load_menu(MENU_SET *p_menu_set, cons
449                                                          log_error("Error menu title col in menu config line %d\n", fin_line);                                                          log_error("Error menu title col in menu config line %d\n", fin_line);
450                                                          return -1;                                                          return -1;
451                                                  }                                                  }
452                                                  p_menu->title.col = atoi(p);                                                  p_menu->title.col = (int16_t)atoi(p);
453    
454                                                  // Menu title text                                                  // Menu title text
455                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITHOUT_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITHOUT_SPACE, &saveptr);
# Line 400  int load_menu(MENU_SET *p_menu_set, cons Line 471  int load_menu(MENU_SET *p_menu_set, cons
471                                                  }                                                  }
472                                                  *q = '\0';                                                  *q = '\0';
473    
474                                                  if (q - p > sizeof(p_item->text) - 1)                                                  if (q - p > sizeof(p_menu_item->text) - 1)
475                                                  {                                                  {
476                                                          log_error("Too longer menu title text in menu config line %d\n", fin_line);                                                          log_error("Too longer menu title text in menu config line %d\n", fin_line);
477                                                          return -1;                                                          return -1;
# Line 418  int load_menu(MENU_SET *p_menu_set, cons Line 489  int load_menu(MENU_SET *p_menu_set, cons
489                                          }                                          }
490                                          else if (strcmp(p, "screen") == 0)                                          else if (strcmp(p, "screen") == 0)
491                                          {                                          {
492                                                  p_menu->screen.show = 1;                                                  p_menu->screen_show = 1;
493    
494                                                  // Menu screen row                                                  // Menu screen row
495                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 437  int load_menu(MENU_SET *p_menu_set, cons Line 508  int load_menu(MENU_SET *p_menu_set, cons
508                                                          log_error("Error menu screen row in menu config line %d\n", fin_line);                                                          log_error("Error menu screen row in menu config line %d\n", fin_line);
509                                                          return -1;                                                          return -1;
510                                                  }                                                  }
511                                                  p_menu->screen.row = atoi(p);                                                  p_menu->screen_row = (int16_t)atoi(p);
512    
513                                                  // Menu screen col                                                  // Menu screen col
514                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 456  int load_menu(MENU_SET *p_menu_set, cons Line 527  int load_menu(MENU_SET *p_menu_set, cons
527                                                          log_error("Error menu screen col in menu config line %d\n", fin_line);                                                          log_error("Error menu screen col in menu config line %d\n", fin_line);
528                                                          return -1;                                                          return -1;
529                                                  }                                                  }
530                                                  p_menu->screen.col = atoi(p);                                                  p_menu->screen_col = (int16_t)atoi(p);
531    
532                                                  // Menu screen name                                                  // Menu screen name
533                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 475  int load_menu(MENU_SET *p_menu_set, cons Line 546  int load_menu(MENU_SET *p_menu_set, cons
546                                                          log_error("Error menu screen name in menu config line %d\n", fin_line);                                                          log_error("Error menu screen name in menu config line %d\n", fin_line);
547                                                          return -1;                                                          return -1;
548                                                  }                                                  }
549                                                    strncpy(p_menu->screen_name, p, sizeof(p_menu->screen_name) - 1);
550                                                  snprintf(p_menu->screen.filename, sizeof(p_menu->screen.filename), "%s%s", MENU_SCREEN_PATH_PREFIX, p);                                                  p_menu->screen_name[sizeof(p_menu->screen_name) - 1] = '\0';
551    
552                                                  // Check syntax                                                  // Check syntax
553                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 490  int load_menu(MENU_SET *p_menu_set, cons Line 561  int load_menu(MENU_SET *p_menu_set, cons
561                          }                          }
562                          else // BEGIN of menu screen                          else // BEGIN of menu screen
563                          {                          {
564                                    if (p_menu_set->menu_item_count >= MAX_MENUS)
565                                    {
566                                            log_error("Menu screen count (%d) exceed limit (%d)\n", p_menu_set->menu_screen_count, MAX_MENUS);
567                                            return -3;
568                                    }
569                                    screen_id = (MENU_SCREEN_ID)p_menu_set->menu_screen_count;
570                                    p_menu_set->menu_screen_count++;
571    
572                                    p_screen = get_menu_screen_by_id(p_menu_set, screen_id);
573    
574                                  q = p;                                  q = p;
575                                  while (isalnum(*q) || *q == '_')                                  while (isalnum(*q) || *q == '_')
576                                  {                                  {
# Line 500  int load_menu(MENU_SET *p_menu_set, cons Line 581  int load_menu(MENU_SET *p_menu_set, cons
581                                          log_error("Error menu screen name in menu config line %d\n", fin_line);                                          log_error("Error menu screen name in menu config line %d\n", fin_line);
582                                          return -1;                                          return -1;
583                                  }                                  }
584                                    strncpy(p_screen->name, p, sizeof(p_screen->name) - 1);
585                                    p_screen->name[sizeof(p_screen->name) - 1] = '\0';
586    
587                                  snprintf(screen_filename, sizeof(screen_filename), "%s%s", MENU_SCREEN_PATH_PREFIX, p);                                  if (trie_dict_set(p_menu_set->p_menu_screen_dict, p_screen->name, (int64_t)screen_id) != 1)
588                                    {
589                                            log_error("Error set menu screen dict [%s]\n", p_screen->name);
590                                    }
591    
592                                  // Check syntax                                  // Check syntax
593                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                  q = strtok_r(NULL, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
# Line 511  int load_menu(MENU_SET *p_menu_set, cons Line 597  int load_menu(MENU_SET *p_menu_set, cons
597                                          return -1;                                          return -1;
598                                  }                                  }
599    
600                                  if ((fout = fopen(screen_filename, "w")) == NULL)                                  p_screen->buf_offset = p_menu_set->p_menu_screen_buf_free - p_menu_set->p_menu_screen_buf;
601                                  {                                  p_screen->buf_length = -1;
602                                          log_error("Open %s failed", screen_filename);  
603                                          return -2;                                  // safety appending boundary
604                                  }                                  q = p_menu_set->p_menu_screen_buf + MAX_MENU_SCR_BUF_LENGTH * MAX_MENUS - 1;
605    
606                                  while (fgets(buffer, sizeof(buffer), fin))                                  while (fgets(buffer, sizeof(buffer), fin))
607                                  {                                  {
608                                          fin_line++;                                          fin_line++;
609    
610                                          strncpy(temp, buffer, sizeof(temp)); // Duplicate line for strtok_r                                          strncpy(temp, buffer, sizeof(temp) - 1); // Duplicate line for strtok_r
611                                            temp[sizeof(temp) - 1] = '\0';
612                                          p = strtok_r(temp, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                          p = strtok_r(temp, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
613                                          if (p != NULL && *p == '%') // END of menu screen                                          if (p != NULL && *p == '%') // END of menu screen
614                                          {                                          {
615                                                    if (p_menu_set->p_menu_screen_buf_free + 1 > q)
616                                                    {
617                                                            log_error("Menu screen buffer depleted (%p + 1 > %p)\n", p_menu_set->p_menu_screen_buf_free, q);
618                                                            return -3;
619                                                    }
620    
621                                                    *(p_menu_set->p_menu_screen_buf_free) = '\0';
622                                                    p_menu_set->p_menu_screen_buf_free++;
623                                                    p_screen->buf_length = p_menu_set->p_menu_screen_buf_free - p_menu_set->p_menu_screen_buf - p_screen->buf_offset;
624                                                  break;                                                  break;
625                                          }                                          }
626    
627                                          if (fputs(buffer, fout) < 0)                                          // Clear line
628                                            if (p_menu_set->p_menu_screen_buf_free + strlen(CTRL_SEQ_CLR_LINE) > q)
629                                            {
630                                                    log_error("Menu screen buffer depleted (%p + %d > %p)\n", p_menu_set->p_menu_screen_buf_free, q, strlen(CTRL_SEQ_CLR_LINE));
631                                                    return -3;
632                                            }
633                                            p_menu_set->p_menu_screen_buf_free = stpcpy(p_menu_set->p_menu_screen_buf_free, CTRL_SEQ_CLR_LINE);
634    
635                                            p = buffer;
636                                            while (*p != '\0')
637                                          {                                          {
638                                                  log_error("Write %s failed", screen_filename);                                                  if (p_menu_set->p_menu_screen_buf_free + 2 > q)
639                                                  return -2;                                                  {
640                                                            log_error("Menu screen buffer depleted (%p + 2 > %p)\n", p_menu_set->p_menu_screen_buf_free, q);
641                                                            return -3;
642                                                    }
643    
644                                                    if (*p == '\n' && p > buffer && *(p - 1) != '\r')
645                                                    {
646                                                            *(p_menu_set->p_menu_screen_buf_free) = '\r';
647                                                            p_menu_set->p_menu_screen_buf_free++;
648                                                    }
649    
650                                                    *(p_menu_set->p_menu_screen_buf_free) = *p;
651                                                    p++;
652                                                    p_menu_set->p_menu_screen_buf_free++;
653                                          }                                          }
654                                  }                                  }
655    
656                                  fclose(fout);                                  if (p_screen->buf_length == -1)
657                                    {
658                                            log_error("End of menu screen [%s] not found\n", p_screen->name);
659                                    }
660                          }                          }
661                  }                  }
662                  else // Invalid prefix                  else // Invalid prefix
# Line 546  int load_menu(MENU_SET *p_menu_set, cons Line 667  int load_menu(MENU_SET *p_menu_set, cons
667          }          }
668          fclose(fin);          fclose(fin);
669    
670          p_menu_set->menu_count = i;          for (menu_id = 0; menu_id < p_menu_set->menu_count; menu_id++)
671          p_menu_set->menu_select_depth = 0;          {
672          p_menu_set->p_menu_select[p_menu_set->menu_select_depth] = (i == 0 ? NULL : p_menu_set->p_menu[0]);                  p_menu = get_menu_by_id(p_menu_set, menu_id);
   
         return 0;  
 }  
673    
674  MENU *get_menu(MENU_SET *p_menu_set, const char *menu_name)                  if (trie_dict_get(p_menu_set->p_menu_screen_dict, p_menu->screen_name, (int64_t *)(&(p_menu->screen_id))) != 1)
675  {                  {
676          int i;                          log_error("Undefined menu screen [%s]\n", p);
677                            return -1;
678                    }
679            }
680    
681          for (i = 0; i < p_menu_set->menu_count; i++)          for (menu_item_id = 0; menu_item_id < p_menu_set->menu_item_count; menu_item_id++)
682          {          {
683                  if (strcmp(p_menu_set->p_menu[i]->name, menu_name) == 0)                  p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
684    
685                    // Set menu_item->action_cmd_handler of each menu item pointing to bbs_cmd
686                    if (p_menu_item->submenu == 0)
687                  {                  {
688                          return p_menu_set->p_menu[i];                          if ((p_menu_item->action_cmd_handler = get_cmd_handler(p_menu_item->action)) == NULL)
689                            {
690                                    log_error("Undefined menu action cmd handler [%s]\n", p_menu_item->action);
691                                    return -1;
692                            }
693                    }
694                    // Set menu_item->action_menu_id of each menu item pointing to a submenu to the menu_id of the corresponding submenu
695                    else if (strcmp(p_menu_item->action, "..") != 0)
696                    {
697                            if (trie_dict_get(p_menu_set->p_menu_name_dict, p_menu_item->action, (int64_t *)&menu_id) != 1)
698                            {
699                                    log_error("Undefined menu action [%s]\n", p_menu_item->action);
700                                    return -1;
701                            }
702                            p_menu_item->action_menu_id = menu_id;
703                  }                  }
704          }          }
705    
706          return NULL;          // Save status varaibles into reserved memory area
707            *((int16_t *)p_menu_set->p_reserved) = p_menu_set->menu_count;
708            *(((int16_t *)p_menu_set->p_reserved) + 1) = p_menu_set->menu_item_count;
709            *(((int16_t *)p_menu_set->p_reserved) + 2) = p_menu_set->menu_screen_count;
710    
711            return 0;
712  }  }
713    
714  static void display_menu_cursor(MENU *p_menu, int show)  static int display_menu_cursor(MENU_SET *p_menu_set, int show)
715  {  {
716          moveto((p_menu->items[p_menu->item_cur_pos])->r_row,          MENU_ID menu_id;
717                     (p_menu->items[p_menu->item_cur_pos])->r_col - 2);          MENU_ITEM_ID menu_item_id;
718            MENU *p_menu;
719            MENU_ITEM *p_menu_item;
720            int16_t menu_item_pos;
721    
722            menu_id = p_menu_set->menu_id_path[p_menu_set->choose_step];
723            p_menu = get_menu_by_id(p_menu_set, menu_id);
724            if (p_menu == NULL)
725            {
726                    log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
727                    return -1;
728            }
729    
730            menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
731            menu_item_id = p_menu->items[menu_item_pos];
732            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
733            if (p_menu_item == NULL)
734            {
735                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
736                    return -1;
737            }
738    
739            moveto(p_menu_set->menu_item_r_row[menu_item_pos], p_menu_set->menu_item_r_col[menu_item_pos] - 2);
740          outc(show ? '>' : ' ');          outc(show ? '>' : ' ');
741          iflush();          iflush();
742    
743            return 0;
744  }  }
745    
746  int display_menu(MENU *p_menu)  int display_menu(MENU_SET *p_menu_set)
747  {  {
748          int row = 0;          int16_t row = 0;
749          int col = 0;          int16_t col = 0;
750          int menu_selectable = 0;          int menu_selectable = 0;
751            MENU_ID menu_id;
752            MENU_ITEM_ID menu_item_id;
753            MENU *p_menu;
754            MENU_ITEM *p_menu_item;
755            MENU_SCREEN *p_menu_screen;
756            int16_t menu_item_pos;
757    
758            menu_id = p_menu_set->menu_id_path[p_menu_set->choose_step];
759            p_menu = get_menu_by_id(p_menu_set, menu_id);
760          if (p_menu == NULL)          if (p_menu == NULL)
761          {          {
762                    log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
763                  return -1;                  return -1;
764          }          }
765    
766          if (p_menu->item_cur_pos > 0 &&          menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
767                  checkpriv(&BBS_priv, 0, p_menu->items[p_menu->item_cur_pos]->priv) != 0 &&          menu_item_id = p_menu->items[menu_item_pos];
768                  checklevel(&BBS_priv, p_menu->items[p_menu->item_cur_pos]->level) != 0)          p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
769            if (p_menu_item == NULL)
770            {
771                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
772                    return -1;
773            }
774    
775            if (menu_item_pos > 0 &&
776                    checkpriv(&BBS_priv, 0, p_menu_item->priv) != 0 &&
777                    checklevel(&BBS_priv, p_menu_item->level) != 0)
778          {          {
779                  menu_selectable = 1;                  menu_selectable = 1;
780          }          }
# Line 599  int display_menu(MENU *p_menu) Line 784  int display_menu(MENU *p_menu)
784                  show_top(p_menu->title.text);                  show_top(p_menu->title.text);
785          }          }
786    
787          if (p_menu->screen.show)          if (p_menu->screen_show)
788          {          {
789                  moveto(p_menu->screen.row, p_menu->screen.col);                  p_menu_screen = get_menu_screen_by_id(p_menu_set, p_menu->screen_id);
790                  if (display_file(p_menu->screen.filename) != 0)                  if (p_menu_screen == NULL)
791                  {                  {
792                          log_error("Display menu screen <%s> failed!\n",                          log_error("get_menu_screen_by_id(%d) return NULL pointer\n", p_menu->screen_id);
793                                            p_menu->screen.filename);                          return -1;
794                  }                  }
795    
796                    moveto(p_menu->screen_row, p_menu->screen_col);
797                    prints("%s", p_menu_set->p_menu_screen_buf + p_menu_screen->buf_offset);
798                    iflush();
799          }          }
800    
801          for (int i = 0; i < p_menu->item_count; i++)          for (menu_item_pos = 0; menu_item_pos < p_menu->item_count; menu_item_pos++)
802          {          {
803                  if (p_menu->items[i]->row != 0)                  menu_item_id = p_menu->items[menu_item_pos];
804                    p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
805    
806                    if (p_menu_item->row != 0)
807                  {                  {
808                          row = p_menu->items[i]->row;                          row = p_menu_item->row;
809                  }                  }
810                  if (p_menu->items[i]->col != 0)                  if (p_menu_item->col != 0)
811                  {                  {
812                          col = p_menu->items[i]->col;                          col = p_menu_item->col;
813                  }                  }
814    
815                  if (checkpriv(&BBS_priv, 0, p_menu->items[i]->priv) == 0 || checklevel(&BBS_priv, p_menu->items[i]->level) == 0)                  if (checkpriv(&BBS_priv, 0, p_menu_item->priv) == 0 || checklevel(&BBS_priv, p_menu_item->level) == 0)
816                  {                  {
817                          p_menu->items[i]->display = 0;                          p_menu_set->menu_item_display[menu_item_pos] = 0;
818                          p_menu->items[i]->r_row = 0;                          p_menu_set->menu_item_r_row[menu_item_pos] = 0;
819                          p_menu->items[i]->r_col = 0;                          p_menu_set->menu_item_r_col[menu_item_pos] = 0;
820                  }                  }
821                  else                  else
822                  {                  {
823                          p_menu->items[i]->display = 1;                          p_menu_set->menu_item_display[menu_item_pos] = 1;
824    
825                          if (!menu_selectable)                          if (!menu_selectable)
826                          {                          {
827                                  p_menu->item_cur_pos = i;                                  p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
828                                  menu_selectable = 1;                                  menu_selectable = 1;
829                          }                          }
830    
831                          p_menu->items[i]->r_row = row;                          p_menu_set->menu_item_r_row[menu_item_pos] = row;
832                          p_menu->items[i]->r_col = col;                          p_menu_set->menu_item_r_col[menu_item_pos] = col;
833    
834                          moveto(row, col);                          moveto(row, col);
835                          prints("%s", p_menu->items[i]->text);                          prints("%s", p_menu_item->text);
836    
837                          row++;                          row++;
838                  }                  }
# Line 651  int display_menu(MENU *p_menu) Line 843  int display_menu(MENU *p_menu)
843                  return -1;                  return -1;
844          }          }
845    
846          display_menu_cursor(p_menu, 1);          display_menu_cursor(p_menu_set, 1);
847    
848          return 0;          return 0;
849  }  }
850    
 int display_current_menu(MENU_SET *p_menu_set)  
 {  
         MENU *p_menu;  
   
         p_menu = p_menu_set->p_menu_select[p_menu_set->menu_select_depth];  
   
         return display_menu(p_menu);  
 }  
   
851  int menu_control(MENU_SET *p_menu_set, int key)  int menu_control(MENU_SET *p_menu_set, int key)
852  {  {
853          int i;          MENU_ID menu_id;
854            MENU_ITEM_ID menu_item_id;
855          MENU *p_menu;          MENU *p_menu;
856            MENU_ITEM *p_menu_item;
857            int16_t menu_item_pos;
858    
859          if (p_menu_set->menu_count == 0)          if (p_menu_set->menu_count == 0)
860          {          {
861                  return 0;                  return 0;
862          }          }
863    
864          p_menu = p_menu_set->p_menu_select[p_menu_set->menu_select_depth];          menu_id = p_menu_set->menu_id_path[p_menu_set->choose_step];
865            p_menu = get_menu_by_id(p_menu_set, menu_id);
866            if (p_menu == NULL)
867            {
868                    log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
869                    return -1;
870            }
871    
872            if (p_menu->item_count == 0)
873            {
874                    return 0;
875            }
876    
877            menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
878            menu_item_id = p_menu->items[menu_item_pos];
879            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
880            if (p_menu_item == NULL)
881            {
882                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
883                    return -1;
884            }
885    
886          switch (key)          switch (key)
887          {          {
888          case CR:          case CR:
889                    igetch_reset();
890          case KEY_RIGHT:          case KEY_RIGHT:
891                  if (p_menu->items[p_menu->item_cur_pos]->submenu)                  if (p_menu_item->submenu)
892                  {                  {
893                          if (strcmp(p_menu->items[p_menu->item_cur_pos]->action, "..") == 0)                          if (strcmp(p_menu_item->action, "..") == 0)
894                          {                          {
895                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
896                          }                          }
897                          p_menu_set->menu_select_depth++;                          p_menu_set->choose_step++;
898                          p_menu = get_menu(p_menu_set, p_menu->items[p_menu->item_cur_pos]->action);                          p_menu_set->menu_id_path[p_menu_set->choose_step] = p_menu_item->action_menu_id;
899                          p_menu_set->p_menu_select[p_menu_set->menu_select_depth] = p_menu;                          p_menu_set->menu_item_pos[p_menu_set->choose_step] = 0;
900    
901                          if (display_menu(p_menu) != 0)                          if (display_menu(p_menu_set) != 0)
902                          {                          {
903                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
904                          }                          }
905                  }                  }
906                  else                  else
907                  {                  {
908                          return (exec_cmd(p_menu->items[p_menu->item_cur_pos]->action,                          return ((*(p_menu_item->action_cmd_handler))((void *)(p_menu_item->name)));
                                                          p_menu->items[p_menu->item_cur_pos]->name));  
909                  }                  }
910                  break;                  break;
911          case KEY_LEFT:          case KEY_LEFT:
912                  if (p_menu_set->menu_select_depth > 0)                  if (p_menu_set->choose_step > 0)
913                  {                  {
914                          p_menu_set->menu_select_depth--;                          p_menu_set->choose_step--;
915                          if (display_current_menu(p_menu_set) != 0)                          if (display_menu(p_menu_set) != 0)
916                          {                          {
917                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
918                          }                          }
919                  }                  }
920                  else                  else
921                  {                  {
922                          display_menu_cursor(p_menu, 0);                          display_menu_cursor(p_menu_set, 0);
923                          p_menu->item_cur_pos = p_menu->item_count - 1;                          menu_item_pos = p_menu->item_count - 1;
924                          while (p_menu->item_cur_pos >= 0 && (!p_menu->items[p_menu->item_cur_pos]->display ||                          while (menu_item_pos >= 0)
                                                                                                  p_menu->items[p_menu->item_cur_pos]->priv != 0 ||  
                                                                                                  p_menu->items[p_menu->item_cur_pos]->level != 0))  
925                          {                          {
926                                  p_menu->item_cur_pos--;                                  menu_item_id = p_menu->items[menu_item_pos];
927                                    p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
928                                    if (p_menu_item == NULL)
929                                    {
930                                            log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
931                                            return -1;
932                                    }
933    
934                                    if (!p_menu_set->menu_item_display[menu_item_pos] || p_menu_item->priv != 0 || p_menu_item->level != 0)
935                                    {
936                                            menu_item_pos--;
937                                    }
938                                    else
939                                    {
940                                            break;
941                                    }
942                          }                          }
943                          display_menu_cursor(p_menu, 1);                          p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
944                            display_menu_cursor(p_menu_set, 1);
945                  }                  }
946                  break;                  break;
947          case KEY_UP:          case KEY_UP:
948                  display_menu_cursor(p_menu, 0);                  display_menu_cursor(p_menu_set, 0);
949                  do                  do
950                  {                  {
951                          p_menu->item_cur_pos--;                          menu_item_pos--;
952                          if (p_menu->item_cur_pos < 0)                          if (menu_item_pos < 0)
953                          {                          {
954                                  p_menu->item_cur_pos = p_menu->item_count - 1;                                  menu_item_pos = p_menu->item_count - 1;
955                          }                          }
956                  } while (!p_menu->items[p_menu->item_cur_pos]->display);                          menu_item_id = p_menu->items[menu_item_pos];
957                  display_menu_cursor(p_menu, 1);                          p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
958                            if (p_menu_item == NULL)
959                            {
960                                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
961                                    return -1;
962                            }
963                    } while (!p_menu_set->menu_item_display[menu_item_pos]);
964                    p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
965                    display_menu_cursor(p_menu_set, 1);
966                  break;                  break;
967          case KEY_DOWN:          case KEY_DOWN:
968                  display_menu_cursor(p_menu, 0);                  display_menu_cursor(p_menu_set, 0);
969                  do                  do
970                  {                  {
971                          p_menu->item_cur_pos++;                          menu_item_pos++;
972                          if (p_menu->item_cur_pos >= p_menu->item_count)                          if (menu_item_pos >= p_menu->item_count)
973                            {
974                                    menu_item_pos = 0;
975                            }
976                            menu_item_id = p_menu->items[menu_item_pos];
977                            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
978                            if (p_menu_item == NULL)
979                            {
980                                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
981                                    return -1;
982                            }
983                    } while (!p_menu_set->menu_item_display[menu_item_pos]);
984                    p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
985                    display_menu_cursor(p_menu_set, 1);
986                    break;
987            case KEY_HOME:
988            case KEY_PGUP:
989                    display_menu_cursor(p_menu_set, 0);
990                    menu_item_pos = 0;
991                    while (menu_item_pos < p_menu->item_count - 1)
992                    {
993                            menu_item_id = p_menu->items[menu_item_pos];
994                            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
995                            if (p_menu_item == NULL)
996                            {
997                                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
998                                    return -1;
999                            }
1000    
1001                            if (p_menu_set->menu_item_display[menu_item_pos])
1002                            {
1003                                    break;
1004                            }
1005    
1006                            menu_item_pos++;
1007                    }
1008                    p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
1009                    display_menu_cursor(p_menu_set, 1);
1010                    break;
1011            case KEY_END:
1012            case KEY_PGDN:
1013                    display_menu_cursor(p_menu_set, 0);
1014                    menu_item_pos = p_menu->item_count - 1;
1015                    while (menu_item_pos > 0)
1016                    {
1017                            menu_item_id = p_menu->items[menu_item_pos];
1018                            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
1019                            if (p_menu_item == NULL)
1020                          {                          {
1021                                  p_menu->item_cur_pos = 0;                                  log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
1022                                    return -1;
1023                          }                          }
1024                  } while (!p_menu->items[p_menu->item_cur_pos]->display);  
1025                  display_menu_cursor(p_menu, 1);                          if (p_menu_set->menu_item_display[menu_item_pos])
1026                            {
1027                                    break;
1028                            }
1029    
1030                            menu_item_pos--;
1031                    }
1032                    p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
1033                    display_menu_cursor(p_menu_set, 1);
1034                  break;                  break;
1035          default:          default:
1036                  if (isalnum(key))                  if (isalnum(key))
1037                  {                  {
1038                          for (i = 0; i < p_menu->item_count; i++)                          for (menu_item_pos = 0; menu_item_pos < p_menu->item_count; menu_item_pos++)
1039                          {                          {
1040                                  if (toupper(key) == toupper(p_menu->items[i]->name[0]) &&                                  menu_item_id = p_menu->items[menu_item_pos];
1041                                          p_menu->items[i]->display)                                  p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
1042                                    if (p_menu_item == NULL)
1043                                    {
1044                                            log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
1045                                            return -1;
1046                                    }
1047    
1048                                    if (toupper(key) == toupper(p_menu_item->name[0]) && p_menu_set->menu_item_display[menu_item_pos])
1049                                  {                                  {
1050                                          display_menu_cursor(p_menu, 0);                                          display_menu_cursor(p_menu_set, 0);
1051                                          p_menu->item_cur_pos = i;                                          p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
1052                                          display_menu_cursor(p_menu, 1);                                          display_menu_cursor(p_menu_set, 1);
1053                                          return 0;                                          return 0;
1054                                  }                                  }
1055                          }                          }
# Line 769  int menu_control(MENU_SET *p_menu_set, i Line 1060  int menu_control(MENU_SET *p_menu_set, i
1060          return 0;          return 0;
1061  }  }
1062    
1063  void unload_menu(MENU_SET *p_menu_set)  int unload_menu(MENU_SET *p_menu_set)
1064  {  {
1065          MENU *p_menu;          if (p_menu_set->p_menu_name_dict != NULL)
1066          int i, j;          {
1067                    trie_dict_destroy(p_menu_set->p_menu_name_dict);
1068                    p_menu_set->p_menu_name_dict = NULL;
1069            }
1070    
1071          for (i = 0; i < p_menu_set->menu_count; i++)          if (p_menu_set->p_menu_screen_dict != NULL)
1072          {          {
1073                  p_menu = p_menu_set->p_menu[i];                  trie_dict_destroy(p_menu_set->p_menu_screen_dict);
1074                  for (j = 0; j < p_menu->item_count; j++)                  p_menu_set->p_menu_screen_dict = NULL;
1075            }
1076    
1077            unload_menu_shm(p_menu_set);
1078    
1079            if (shmctl(p_menu_set->shmid, IPC_RMID, NULL) == -1)
1080            {
1081                    log_error("shmctl(shmid=%d, IPC_RMID) error (%d)\n", p_menu_set->shmid, errno);
1082                    return -1;
1083            }
1084    
1085            return 0;
1086    }
1087    
1088    int load_menu_shm(MENU_SET *p_menu_set)
1089    {
1090            // Mount shared memory
1091            if (p_menu_set->p_reserved == NULL)
1092            {
1093                    p_menu_set->p_reserved = shmat(p_menu_set->shmid, NULL, SHM_RDONLY);
1094                    if (p_menu_set->p_reserved == (void *)-1)
1095                  {                  {
1096                          free(p_menu->items[j]);                          log_error("shmat() error (%d)\n", errno);
1097                            return -1;
1098                  }                  }
                 free(p_menu);  
1099          }          }
1100    
1101          p_menu_set->menu_count = 0;          p_menu_set->p_menu_pool = p_menu_set->p_reserved + MENU_SET_RESERVED_LENGTH;
1102          p_menu_set->menu_select_depth = 0;          p_menu_set->p_menu_item_pool = p_menu_set->p_menu_pool + sizeof(MENU) * MAX_MENUS;
1103            p_menu_set->p_menu_screen_pool = p_menu_set->p_menu_item_pool + sizeof(MENU_ITEM) * MAX_MENUITEMS;
1104            p_menu_set->p_menu_screen_buf = p_menu_set->p_menu_screen_pool + sizeof(MENU_SCREEN) * MAX_MENUS;
1105            p_menu_set->p_menu_screen_buf_free = p_menu_set->p_menu_screen_buf;
1106    
1107            // Restore status varaibles into reserved memory area
1108            p_menu_set->menu_count = *((int16_t *)p_menu_set->p_reserved);
1109            p_menu_set->menu_item_count = *(((int16_t *)p_menu_set->p_reserved) + 1);
1110            p_menu_set->menu_screen_count = *(((int16_t *)p_menu_set->p_reserved) + 2);
1111    
1112            p_menu_set->choose_step = 0;
1113            p_menu_set->menu_id_path[0] = 0;
1114    
1115            p_menu_set->p_menu_name_dict = NULL;
1116            p_menu_set->p_menu_screen_dict = NULL;
1117    
1118            return 0;
1119  }  }
1120    
1121  int reload_menu(MENU_SET *p_menu_set)  int unload_menu_shm(MENU_SET *p_menu_set)
1122  {  {
1123          int result;          p_menu_set->menu_count = 0;
1124          char conf_file[FILE_PATH_LEN];          p_menu_set->menu_item_count = 0;
1125            p_menu_set->menu_screen_count = 0;
1126          strncpy(conf_file, p_menu_set->conf_file, sizeof(conf_file) - 1);          p_menu_set->choose_step = 0;
1127          conf_file[sizeof(conf_file) - 1] = '\0';  
1128            p_menu_set->p_menu_pool = NULL;
1129            p_menu_set->p_menu_item_pool = NULL;
1130            p_menu_set->p_menu_screen_pool = NULL;
1131            p_menu_set->p_menu_screen_buf = NULL;
1132            p_menu_set->p_menu_screen_buf_free = NULL;
1133    
1134          unload_menu(p_menu_set);          if (p_menu_set->p_reserved != NULL && shmdt(p_menu_set->p_reserved) == -1)
1135          result = load_menu(p_menu_set, conf_file);          {
1136                    log_error("shmdt() error (%d)\n", errno);
1137                    return -1;
1138            }
1139            p_menu_set->p_reserved = NULL;
1140    
1141          return result;          return 0;
1142  }  }

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1