/[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.40 by sysadm, Thu May 15 05:14:57 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                                                    if (trie_dict_get(p_menu_set->p_menu_screen_dict, p, (int64_t *)&screen_id) != 1)
550                                                  snprintf(p_menu->screen.filename, sizeof(p_menu->screen.filename), "%s%s", MENU_SCREEN_PATH_PREFIX, p);                                                  {
551                                                            log_error("Undefined menu screen [%s]\n", p);
552                                                            return -1;
553                                                    }
554                                                    p_menu->screen_id = screen_id;
555    
556                                                  // Check syntax                                                  // Check syntax
557                                                  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 565  int load_menu(MENU_SET *p_menu_set, cons
565                          }                          }
566                          else // BEGIN of menu screen                          else // BEGIN of menu screen
567                          {                          {
568                                    if (p_menu_set->menu_item_count >= MAX_MENUS)
569                                    {
570                                            log_error("Menu screen count (%d) exceed limit (%d)\n", p_menu_set->menu_screen_count, MAX_MENUS);
571                                            return -3;
572                                    }
573                                    screen_id = (MENU_SCREEN_ID)p_menu_set->menu_screen_count;
574                                    p_menu_set->menu_screen_count++;
575    
576                                    p_screen = get_menu_screen_by_id(p_menu_set, screen_id);
577    
578                                  q = p;                                  q = p;
579                                  while (isalnum(*q) || *q == '_')                                  while (isalnum(*q) || *q == '_')
580                                  {                                  {
# Line 500  int load_menu(MENU_SET *p_menu_set, cons Line 585  int load_menu(MENU_SET *p_menu_set, cons
585                                          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);
586                                          return -1;                                          return -1;
587                                  }                                  }
588                                    strncpy(p_screen->name, p, sizeof(p_screen->name) - 1);
589                                    p_screen->name[sizeof(p_screen->name) - 1] = '\0';
590    
591                                  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)
592                                    {
593                                            log_error("Error set menu screen dict [%s]\n", p_screen->name);
594                                    }
595    
596                                  // Check syntax                                  // Check syntax
597                                  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 601  int load_menu(MENU_SET *p_menu_set, cons
601                                          return -1;                                          return -1;
602                                  }                                  }
603    
604                                  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;
605                                  {                                  p_screen->buf_length = -1;
606                                          log_error("Open %s failed", screen_filename);  
607                                          return -2;                                  // safety appending boundary
608                                  }                                  q = p_menu_set->p_menu_screen_buf + MAX_MENU_SCR_BUF_LENGTH * MAX_MENUS - 1;
609    
610                                  while (fgets(buffer, sizeof(buffer), fin))                                  while (fgets(buffer, sizeof(buffer), fin))
611                                  {                                  {
612                                          fin_line++;                                          fin_line++;
613    
614                                          strncpy(temp, buffer, sizeof(temp)); // Duplicate line for strtok_r                                          strncpy(temp, buffer, sizeof(temp) - 1); // Duplicate line for strtok_r
615                                            temp[sizeof(temp) - 1] = '\0';
616                                          p = strtok_r(temp, MENU_CONF_DELIM_WITH_SPACE, &saveptr);                                          p = strtok_r(temp, MENU_CONF_DELIM_WITH_SPACE, &saveptr);
617                                          if (p != NULL && *p == '%') // END of menu screen                                          if (p != NULL && *p == '%') // END of menu screen
618                                          {                                          {
619                                                    if (p_menu_set->p_menu_screen_buf_free + 1 > q)
620                                                    {
621                                                            log_error("Menu screen buffer depleted (%p + 1 > %p)\n", p_menu_set->p_menu_screen_buf_free, q);
622                                                            return -3;
623                                                    }
624    
625                                                    *(p_menu_set->p_menu_screen_buf_free) = '\0';
626                                                    p_menu_set->p_menu_screen_buf_free++;
627                                                    p_screen->buf_length = p_menu_set->p_menu_screen_buf_free - p_menu_set->p_menu_screen_buf - p_screen->buf_offset;
628                                                  break;                                                  break;
629                                          }                                          }
630    
631                                          if (fputs(buffer, fout) < 0)                                          p = buffer;
632                                            while (*p != '\0')
633                                          {                                          {
634                                                  log_error("Write %s failed", screen_filename);                                                  if (p_menu_set->p_menu_screen_buf_free + 2 > q)
635                                                  return -2;                                                  {
636                                                            log_error("Menu screen buffer depleted (%p + 2 > %p)\n", p_menu_set->p_menu_screen_buf_free, q);
637                                                            return -3;
638                                                    }
639    
640                                                    if (*p == '\n' && p > buffer && *(p - 1) != '\r')
641                                                    {
642                                                            *(p_menu_set->p_menu_screen_buf_free) = '\r';
643                                                            p_menu_set->p_menu_screen_buf_free++;
644                                                    }
645    
646                                                    *(p_menu_set->p_menu_screen_buf_free) = *p;
647                                                    p++;
648                                                    p_menu_set->p_menu_screen_buf_free++;
649                                          }                                          }
650                                  }                                  }
651    
652                                  fclose(fout);                                  if (p_screen->buf_length == -1)
653                                    {
654                                            log_error("End of menu screen [%s] not found\n", p_screen->name);
655                                    }
656                          }                          }
657                  }                  }
658                  else // Invalid prefix                  else // Invalid prefix
# Line 546  int load_menu(MENU_SET *p_menu_set, cons Line 663  int load_menu(MENU_SET *p_menu_set, cons
663          }          }
664          fclose(fin);          fclose(fin);
665    
666          p_menu_set->menu_count = i;          // Set menu_item->action_menu_id of each menu item pointing to a submenu to the menu_id of the corresponding submenu
667          p_menu_set->menu_select_depth = 0;          for (menu_item_id = 0; menu_item_id < p_menu_set->menu_item_count; menu_item_id++)
668          p_menu_set->p_menu_select[p_menu_set->menu_select_depth] = (i == 0 ? NULL : p_menu_set->p_menu[0]);          {
669                    p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
670                    if (p_menu_item->submenu == 1 && strcmp(p_menu_item->action, "..") != 0)
671                    {
672                            if (trie_dict_get(p_menu_set->p_menu_name_dict, p_menu_item->action, (int64_t *)&menu_id) != 1)
673                            {
674                                    log_error("Undefined menu action [%s]\n", p_menu_item->action);
675                                    return -1;
676                            }
677                            p_menu_item->action_menu_id = menu_id;
678                    }
679            }
680    
681            // Save status varaibles into reserved memory area
682            *((int16_t *)p_menu_set->p_reserved) = p_menu_set->menu_count;
683            *(((int16_t *)p_menu_set->p_reserved) + 1) = p_menu_set->menu_item_count;
684            *(((int16_t *)p_menu_set->p_reserved) + 2) = p_menu_set->menu_screen_count;
685    
686          return 0;          return 0;
687  }  }
688    
689  MENU *get_menu(MENU_SET *p_menu_set, const char *menu_name)  static int display_menu_cursor(MENU_SET *p_menu_set, int show)
690  {  {
691          int i;          MENU_ID menu_id;
692            MENU_ITEM_ID menu_item_id;
693            MENU *p_menu;
694            MENU_ITEM *p_menu_item;
695            int16_t menu_item_pos;
696    
697          for (i = 0; i < p_menu_set->menu_count; i++)          menu_id = p_menu_set->menu_id_path[p_menu_set->choose_step];
698            p_menu = get_menu_by_id(p_menu_set, menu_id);
699            if (p_menu == NULL)
700          {          {
701                  if (strcmp(p_menu_set->p_menu[i]->name, menu_name) == 0)                  log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
702                  {                  return -1;
                         return p_menu_set->p_menu[i];  
                 }  
703          }          }
704    
705          return NULL;          menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
706  }          menu_item_id = p_menu->items[menu_item_pos];
707            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
708            if (p_menu_item == NULL)
709            {
710                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
711                    return -1;
712            }
713    
714  static void display_menu_cursor(MENU *p_menu, int show)          moveto(p_menu_item->r_row, p_menu_item->r_col - 2);
 {  
         moveto((p_menu->items[p_menu->item_cur_pos])->r_row,  
                    (p_menu->items[p_menu->item_cur_pos])->r_col - 2);  
715          outc(show ? '>' : ' ');          outc(show ? '>' : ' ');
716          iflush();          iflush();
717    
718            return 0;
719  }  }
720    
721  int display_menu(MENU *p_menu)  int display_menu(MENU_SET *p_menu_set)
722  {  {
723          int row = 0;          int16_t row = 0;
724          int col = 0;          int16_t col = 0;
725          int menu_selectable = 0;          int menu_selectable = 0;
726            MENU_ID menu_id;
727            MENU_ITEM_ID menu_item_id;
728            MENU *p_menu;
729            MENU_ITEM *p_menu_item;
730            MENU_SCREEN *p_menu_screen;
731            int16_t menu_item_pos;
732    
733            menu_id = p_menu_set->menu_id_path[p_menu_set->choose_step];
734            p_menu = get_menu_by_id(p_menu_set, menu_id);
735          if (p_menu == NULL)          if (p_menu == NULL)
736          {          {
737                    log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
738                  return -1;                  return -1;
739          }          }
740    
741          if (p_menu->item_cur_pos > 0 &&          menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
742                  checkpriv(&BBS_priv, 0, p_menu->items[p_menu->item_cur_pos]->priv) != 0 &&          menu_item_id = p_menu->items[menu_item_pos];
743                  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);
744            if (p_menu_item == NULL)
745            {
746                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
747                    return -1;
748            }
749    
750            if (menu_item_pos > 0 &&
751                    checkpriv(&BBS_priv, 0, p_menu_item->priv) != 0 &&
752                    checklevel(&BBS_priv, p_menu_item->level) != 0)
753          {          {
754                  menu_selectable = 1;                  menu_selectable = 1;
755          }          }
# Line 599  int display_menu(MENU *p_menu) Line 759  int display_menu(MENU *p_menu)
759                  show_top(p_menu->title.text);                  show_top(p_menu->title.text);
760          }          }
761    
762          if (p_menu->screen.show)          if (p_menu->screen_show)
763          {          {
764                  moveto(p_menu->screen.row, p_menu->screen.col);                  p_menu_screen = get_menu_screen_by_id(p_menu_set, p_menu->screen_id);
765                  if (display_file(p_menu->screen.filename) != 0)                  if (p_menu_screen == NULL)
766                  {                  {
767                          log_error("Display menu screen <%s> failed!\n",                          log_error("get_menu_screen_by_id(%d) return NULL pointer\n", p_menu->screen_id);
768                                            p_menu->screen.filename);                          return -1;
769                  }                  }
770    
771                    moveto(p_menu->screen_row, p_menu->screen_col);
772                    prints("%s", p_menu_set->p_menu_screen_buf + p_menu_screen->buf_offset);
773                    iflush();
774          }          }
775    
776          for (int i = 0; i < p_menu->item_count; i++)          for (int16_t i = 0; i < p_menu->item_count; i++)
777          {          {
778                  if (p_menu->items[i]->row != 0)                  menu_item_id = p_menu->items[i];
779                    p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
780    
781                    if (p_menu_item->row != 0)
782                  {                  {
783                          row = p_menu->items[i]->row;                          row = p_menu_item->row;
784                  }                  }
785                  if (p_menu->items[i]->col != 0)                  if (p_menu_item->col != 0)
786                  {                  {
787                          col = p_menu->items[i]->col;                          col = p_menu_item->col;
788                  }                  }
789    
790                  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)
791                  {                  {
792                          p_menu->items[i]->display = 0;                          p_menu_item->display = 0;
793                          p_menu->items[i]->r_row = 0;                          p_menu_item->r_row = 0;
794                          p_menu->items[i]->r_col = 0;                          p_menu_item->r_col = 0;
795                  }                  }
796                  else                  else
797                  {                  {
798                          p_menu->items[i]->display = 1;                          p_menu_item->display = 1;
799    
800                          if (!menu_selectable)                          if (!menu_selectable)
801                          {                          {
802                                  p_menu->item_cur_pos = i;                                  p_menu_set->menu_item_pos[p_menu_set->choose_step] = i;
803                                  menu_selectable = 1;                                  menu_selectable = 1;
804                          }                          }
805    
806                          p_menu->items[i]->r_row = row;                          p_menu_item->r_row = row;
807                          p_menu->items[i]->r_col = col;                          p_menu_item->r_col = col;
808    
809                          moveto(row, col);                          moveto(row, col);
810                          prints("%s", p_menu->items[i]->text);                          prints("%s", p_menu_item->text);
811    
812                          row++;                          row++;
813                  }                  }
# Line 651  int display_menu(MENU *p_menu) Line 818  int display_menu(MENU *p_menu)
818                  return -1;                  return -1;
819          }          }
820    
821          display_menu_cursor(p_menu, 1);          display_menu_cursor(p_menu_set, 1);
822    
823          return 0;          return 0;
824  }  }
825    
 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);  
 }  
   
826  int menu_control(MENU_SET *p_menu_set, int key)  int menu_control(MENU_SET *p_menu_set, int key)
827  {  {
828          int i;          MENU_ID menu_id;
829            MENU_ITEM_ID menu_item_id;
830          MENU *p_menu;          MENU *p_menu;
831            MENU_ITEM *p_menu_item;
832            int16_t menu_item_pos;
833    
834          if (p_menu_set->menu_count == 0)          if (p_menu_set->menu_count == 0)
835          {          {
836                  return 0;                  return 0;
837          }          }
838    
839          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];
840            p_menu = get_menu_by_id(p_menu_set, menu_id);
841            if (p_menu == NULL)
842            {
843                    log_error("get_menu_by_id(%d) return NULL pointer\n", menu_id);
844                    return -1;
845            }
846    
847            if (p_menu->item_count == 0)
848            {
849                    return 0;
850            }
851    
852            menu_item_pos = p_menu_set->menu_item_pos[p_menu_set->choose_step];
853            menu_item_id = p_menu->items[menu_item_pos];
854            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
855            if (p_menu_item == NULL)
856            {
857                    log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
858                    return -1;
859            }
860    
861          switch (key)          switch (key)
862          {          {
863          case CR:          case CR:
864                    igetch_reset();
865          case KEY_RIGHT:          case KEY_RIGHT:
866                  if (p_menu->items[p_menu->item_cur_pos]->submenu)                  if (p_menu_item->submenu)
867                  {                  {
868                          if (strcmp(p_menu->items[p_menu->item_cur_pos]->action, "..") == 0)                          if (strcmp(p_menu_item->action, "..") == 0)
869                          {                          {
870                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
871                          }                          }
872                          p_menu_set->menu_select_depth++;                          p_menu_set->choose_step++;
873                          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;
874                          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;
875    
876                          if (display_menu(p_menu) != 0)                          if (display_menu(p_menu_set) != 0)
877                          {                          {
878                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
879                          }                          }
880                  }                  }
881                  else                  else
882                  {                  {
883                          return (exec_cmd(p_menu->items[p_menu->item_cur_pos]->action,                          return (exec_cmd(p_menu_item->action, p_menu_item->name));
                                                          p_menu->items[p_menu->item_cur_pos]->name));  
884                  }                  }
885                  break;                  break;
886          case KEY_LEFT:          case KEY_LEFT:
887                  if (p_menu_set->menu_select_depth > 0)                  if (p_menu_set->choose_step > 0)
888                  {                  {
889                          p_menu_set->menu_select_depth--;                          p_menu_set->choose_step--;
890                          if (display_current_menu(p_menu_set) != 0)                          if (display_menu(p_menu_set) != 0)
891                          {                          {
892                                  return menu_control(p_menu_set, KEY_LEFT);                                  return menu_control(p_menu_set, KEY_LEFT);
893                          }                          }
894                  }                  }
895                  else                  else
896                  {                  {
897                          display_menu_cursor(p_menu, 0);                          display_menu_cursor(p_menu_set, 0);
898                          p_menu->item_cur_pos = p_menu->item_count - 1;                          menu_item_pos = p_menu->item_count - 1;
899                          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))  
900                          {                          {
901                                  p_menu->item_cur_pos--;                                  menu_item_id = p_menu->items[menu_item_pos];
902                                    p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
903                                    if (p_menu_item == NULL)
904                                    {
905                                            log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
906                                            return -1;
907                                    }
908    
909                                    if (!p_menu_item->display || p_menu_item->priv != 0 || p_menu_item->level != 0)
910                                    {
911                                            menu_item_pos--;
912                                    }
913                                    else
914                                    {
915                                            break;
916                                    }
917                          }                          }
918                          display_menu_cursor(p_menu, 1);                          p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
919                            display_menu_cursor(p_menu_set, 1);
920                  }                  }
921                  break;                  break;
922          case KEY_UP:          case KEY_UP:
923                  display_menu_cursor(p_menu, 0);                  display_menu_cursor(p_menu_set, 0);
924                  do                  do
925                  {                  {
926                          p_menu->item_cur_pos--;                          menu_item_pos--;
927                          if (p_menu->item_cur_pos < 0)                          if (menu_item_pos < 0)
928                            {
929                                    menu_item_pos = p_menu->item_count - 1;
930                            }
931                            menu_item_id = p_menu->items[menu_item_pos];
932                            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
933                            if (p_menu_item == NULL)
934                          {                          {
935                                  p_menu->item_cur_pos = p_menu->item_count - 1;                                  log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
936                                    return -1;
937                          }                          }
938                  } while (!p_menu->items[p_menu->item_cur_pos]->display);                  } while (!p_menu_item->display);
939                  display_menu_cursor(p_menu, 1);                  p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
940                    display_menu_cursor(p_menu_set, 1);
941                  break;                  break;
942          case KEY_DOWN:          case KEY_DOWN:
943                  display_menu_cursor(p_menu, 0);                  display_menu_cursor(p_menu_set, 0);
944                  do                  do
945                  {                  {
946                          p_menu->item_cur_pos++;                          menu_item_pos++;
947                          if (p_menu->item_cur_pos >= p_menu->item_count)                          if (menu_item_pos >= p_menu->item_count)
948                            {
949                                    menu_item_pos = 0;
950                            }
951                            menu_item_id = p_menu->items[menu_item_pos];
952                            p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
953                            if (p_menu_item == NULL)
954                          {                          {
955                                  p_menu->item_cur_pos = 0;                                  log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
956                                    return -1;
957                          }                          }
958                  } while (!p_menu->items[p_menu->item_cur_pos]->display);                  } while (!p_menu_item->display);
959                  display_menu_cursor(p_menu, 1);                  p_menu_set->menu_item_pos[p_menu_set->choose_step] = menu_item_pos;
960                    display_menu_cursor(p_menu_set, 1);
961                  break;                  break;
962          default:          default:
963                  if (isalnum(key))                  if (isalnum(key))
964                  {                  {
965                          for (i = 0; i < p_menu->item_count; i++)                          for (int16_t i = 0; i < p_menu->item_count; i++)
966                          {                          {
967                                  if (toupper(key) == toupper(p_menu->items[i]->name[0]) &&                                  menu_item_id = p_menu->items[i];
968                                          p_menu->items[i]->display)                                  p_menu_item = get_menu_item_by_id(p_menu_set, menu_item_id);
969                                    if (p_menu_item == NULL)
970                                    {
971                                            log_error("get_menu_item_by_id(%d) return NULL pointer\n", menu_item_id);
972                                            return -1;
973                                    }
974    
975                                    if (toupper(key) == toupper(p_menu_item->name[0]) && p_menu_item->display)
976                                  {                                  {
977                                          display_menu_cursor(p_menu, 0);                                          display_menu_cursor(p_menu_set, 0);
978                                          p_menu->item_cur_pos = i;                                          p_menu_set->menu_item_pos[p_menu_set->choose_step] = i;
979                                          display_menu_cursor(p_menu, 1);                                          display_menu_cursor(p_menu_set, 1);
980                                          return 0;                                          return 0;
981                                  }                                  }
982                          }                          }
# Line 769  int menu_control(MENU_SET *p_menu_set, i Line 987  int menu_control(MENU_SET *p_menu_set, i
987          return 0;          return 0;
988  }  }
989    
990  void unload_menu(MENU_SET *p_menu_set)  int unload_menu(MENU_SET *p_menu_set)
991  {  {
992          MENU *p_menu;          if (p_menu_set->p_menu_name_dict != NULL)
993          int i, j;          {
994                    trie_dict_destroy(p_menu_set->p_menu_name_dict);
995                    p_menu_set->p_menu_name_dict = NULL;
996            }
997    
998          for (i = 0; i < p_menu_set->menu_count; i++)          if (p_menu_set->p_menu_screen_dict != NULL)
999          {          {
1000                  p_menu = p_menu_set->p_menu[i];                  trie_dict_destroy(p_menu_set->p_menu_screen_dict);
1001                  for (j = 0; j < p_menu->item_count; j++)                  p_menu_set->p_menu_screen_dict = NULL;
                 {  
                         free(p_menu->items[j]);  
                 }  
                 free(p_menu);  
1002          }          }
1003    
1004          p_menu_set->menu_count = 0;          unload_menu_shm(p_menu_set);
1005          p_menu_set->menu_select_depth = 0;  
1006            if (shmctl(p_menu_set->shmid, IPC_RMID, NULL) == -1)
1007            {
1008                    log_error("shmctl(shmid=%d, IPC_RMID) error (%d)\n", p_menu_set->shmid, errno);
1009                    return -1;
1010            }
1011    
1012            return 0;
1013  }  }
1014    
1015  int reload_menu(MENU_SET *p_menu_set)  int load_menu_shm(MENU_SET *p_menu_set)
1016  {  {
1017          int result;          // Mount shared memory
1018          char conf_file[FILE_PATH_LEN];          p_menu_set->p_reserved = shmat(p_menu_set->shmid, NULL, SHM_RDONLY);
1019            if (p_menu_set->p_reserved == (void *)-1)
1020            {
1021                    log_error("shmat() error (%d)\n", errno);
1022                    return -3;
1023            }
1024            p_menu_set->p_menu_pool = p_menu_set->p_reserved + MENU_SET_RESERVED_LENGTH;
1025            p_menu_set->p_menu_item_pool = p_menu_set->p_menu_pool + sizeof(MENU) * MAX_MENUS;
1026            p_menu_set->p_menu_screen_pool = p_menu_set->p_menu_item_pool + sizeof(MENU_ITEM) * MAX_MENUITEMS;
1027            p_menu_set->p_menu_screen_buf = p_menu_set->p_menu_screen_pool + sizeof(MENU_SCREEN) * MAX_MENUS;
1028            p_menu_set->p_menu_screen_buf_free = p_menu_set->p_menu_screen_buf;
1029    
1030            // Restore status varaibles into reserved memory area
1031            p_menu_set->menu_count = *((int16_t *)p_menu_set->p_reserved);
1032            p_menu_set->menu_item_count = *(((int16_t *)p_menu_set->p_reserved) + 1);
1033            p_menu_set->menu_screen_count = *(((int16_t *)p_menu_set->p_reserved) + 2);
1034    
1035          strncpy(conf_file, p_menu_set->conf_file, sizeof(conf_file) - 1);          p_menu_set->choose_step = 0;
1036          conf_file[sizeof(conf_file) - 1] = '\0';          p_menu_set->menu_id_path[0] = 0;
1037    
1038          unload_menu(p_menu_set);          p_menu_set->p_menu_name_dict = NULL;
1039          result = load_menu(p_menu_set, conf_file);          p_menu_set->p_menu_screen_dict = NULL;
1040    
1041          return result;          return 0;
1042    }
1043    
1044    int unload_menu_shm(MENU_SET *p_menu_set)
1045    {
1046            p_menu_set->menu_count = 0;
1047            p_menu_set->menu_item_count = 0;
1048            p_menu_set->menu_screen_count = 0;
1049            p_menu_set->choose_step = 0;
1050    
1051            p_menu_set->p_menu_pool = NULL;
1052            p_menu_set->p_menu_item_pool = NULL;
1053            p_menu_set->p_menu_screen_pool = NULL;
1054            p_menu_set->p_menu_screen_buf = NULL;
1055            p_menu_set->p_menu_screen_buf_free = NULL;
1056    
1057            if (shmdt(p_menu_set->p_reserved) == -1)
1058            {
1059                    log_error("shmdt() error (%d)\n", errno);
1060                    return -1;
1061            }
1062    
1063            p_menu_set->p_reserved = NULL;
1064    
1065            return 0;
1066  }  }

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