28531645955

Committed 01 Jul 2026 04:14PM UTC coverage: 92.468% (-0.6%) from 93.032%

Build # 28531645955

Build Type

push

github

Committed by

web-flow

Commit Message

Exercise caution when reading the client-provided file size for SCP uploads, as it could possibly overflow our size type.

Thanks to Fabian Wahle of Hap Security for reporting this issue.

Coverage Stats

48701 of 52668 relevant lines covered (92.47%)

227.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.45

/src/modules.c

/*
 * ProFTPD - FTP server daemon
 * Copyright (c) 1997, 1998 Public Flood Software
 * Copyright (c) 2001-2026 The ProFTPD Project team
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses/>.
 *
 * As a special exemption, Public Flood Software/MacGyver aka Habeeb J. Dihu
 * and other respective copyright holders give permission to link this program
 * with OpenSSL, and distribute the resulting executable, without including
 * the source code for OpenSSL in the source distribution.
 */

/* Module handling routines */

#include "conf.h"

extern module *static_modules[];
extern module *loaded_modules;

/* Currently running module */
module *curr_module = NULL;

/* Used to track the priority for loaded modules. */
static unsigned int curr_module_pri = 0;

static const char *trace_channel = "module";

modret_t *pr_module_call(module *m, modret_t *(*func)(cmd_rec *),
    cmd_rec *cmd) {
  modret_t *res;
  module *prev_module = curr_module;

  if (m == NULL ||
      func == NULL ||
      cmd == NULL) {
    errno = EINVAL;
    return NULL;
  }

  if (cmd->tmp_pool == NULL) {
    cmd->tmp_pool = make_sub_pool(cmd->pool);
    pr_pool_tag(cmd->tmp_pool, "Module call tmp_pool");
  }

  curr_module = m;
  res = func(cmd);
  curr_module = prev_module;

  /* Note that we don't clear the pool here because the function may
   * return data which resides in this pool.
   */
  return res;
}

modret_t *mod_create_data(cmd_rec *cmd, void *d) {
  modret_t *res;

  if (cmd == NULL) {
    errno = EINVAL;
    return NULL;
  }

  res = pcalloc(cmd->tmp_pool, sizeof(modret_t));
  res->data = d;

  return res;
}

modret_t *mod_create_ret(cmd_rec *cmd, unsigned char err, const char *n,
    const char *m) {
  modret_t *res;

  if (cmd == NULL) {
    errno = EINVAL;
    return NULL;
  }

  res = pcalloc(cmd->tmp_pool, sizeof(modret_t));
  res->mr_handler_module = curr_module;
  res->mr_error = err;

  if (n != NULL) {
    res->mr_numeric = pstrdup(cmd->tmp_pool, n);
  }

  if (m != NULL) {
    res->mr_message = pstrdup(cmd->tmp_pool, m);
  }

  return res;
}

modret_t *mod_create_error(cmd_rec *cmd, int mr_errno) {
  modret_t *res;

  if (cmd == NULL) {
    errno = EINVAL;
    return NULL;
  }

  res = pcalloc(cmd->tmp_pool, sizeof(modret_t));
  res->mr_handler_module = curr_module;
  res->mr_error = mr_errno;

  return res;
}

/* Called after forking in order to inform/initialize modules
 * need to know we are a child and have a connection.
 */
int modules_session_init(void) {
  module *prev_module = curr_module, *m;

  for (m = loaded_modules; m; m = m->next) {
    if (m->sess_init) {
      curr_module = m;

      pr_trace_msg(trace_channel, 12,
        "invoking sess_init callback on mod_%s.c", m->name);
      if (m->sess_init() < 0) {
        int xerrno = errno;

        pr_log_pri(PR_LOG_WARNING,
          "mod_%s.c: error initializing session (%s), check module logs "
          "for details", m->name, strerror(xerrno));

        errno = xerrno;
        return -1;
      }
    }
  }

  curr_module = prev_module;
  return 0;
}

unsigned char command_exists(const char *name) {
  int idx = -1;
  unsigned int hash = 0;
  cmdtable *cmdtab;

  cmdtab = pr_stash_get_symbol2(PR_SYM_CMD, name, NULL, &idx, &hash);
  while (cmdtab && cmdtab->cmd_type != CMD) {
    pr_signals_handle();
    cmdtab = pr_stash_get_symbol2(PR_SYM_CMD, name, cmdtab, &idx, &hash);
  }

  return (cmdtab ? TRUE : FALSE);
}

unsigned char pr_module_exists(const char *name) {
  return pr_module_get(name) != NULL ? TRUE : FALSE;
}

module *pr_module_get(const char *name) {
  char buf[80] = {'\0'};
  module *m;

  if (name == NULL) {
    errno = EINVAL;
    return NULL;
  }

  /* Check the list of compiled-in modules. */
  for (m = loaded_modules; m; m = m->next) {
    memset(buf, '\0', sizeof(buf));
    pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);
    buf[sizeof(buf)-1] = '\0';

    if (strcmp(buf, name) == 0) {
      return m;
    }
  }

  errno = ENOENT;
  return NULL;
}

void modules_list2(int (*listf)(const char *, ...), int flags) {
  if (listf == NULL) {
    listf = printf;
  }

  if (flags & PR_MODULES_LIST_FL_SHOW_STATIC) {
    register unsigned int i = 0;

    listf("Compiled-in modules:\n");
    for (i = 0; static_modules[i]; i++) {
      module *m = static_modules[i];

      if (flags & PR_MODULES_LIST_FL_SHOW_VERSION) {
        const char *version;

        version = m->module_version;
        if (version != NULL) {
          listf("  %s\n", version);

        } else {
          listf("  mod_%s.c\n", m->name);
        }

      } else {
        listf("  mod_%s.c\n", m->name);
      }
    }

  } else {
    module *m;

    listf("Loaded modules:\n");
    for (m = loaded_modules; m; m = m->next) {

      if (flags & PR_MODULES_LIST_FL_SHOW_VERSION) {
        const char *version;

        version = m->module_version;
        if (version != NULL) {
          listf("  %s\n", version);

        } else {
          listf("  mod_%s.c\n", m->name);
        }

      } else {
        listf("  mod_%s.c\n", m->name);
      }
    }
  }
}

void modules_list(int flags) {
  modules_list2(NULL, flags);
}

int pr_module_load_authtab(module *m) {
  if (m == NULL ||
      m->name == NULL) {
    errno = EINVAL;
    return -1;
  }

  if (m->authtable) {
    authtable *authtab;

    for (authtab = m->authtable; authtab->name; authtab++) {
      authtab->m = m;

      if (pr_stash_add_symbol(PR_SYM_AUTH, authtab) < 0) {
        return -1;
      }
    }
  }

  return 0;
}

int pr_module_load_cmdtab(module *m) {
  if (m == NULL ||
      m->name == NULL) {
    errno = EINVAL;
    return -1;
  }

  if (m->cmdtable) {
    cmdtable *cmdtab;

    for (cmdtab = m->cmdtable; cmdtab->command; cmdtab++) {
      cmdtab->m = m;

      if (cmdtab->cmd_type == HOOK) {
        if (pr_stash_add_symbol(PR_SYM_HOOK, cmdtab) < 0) {
          return -1;
        }

      } else {
        /* All other cmd_types are for CMDs: PRE_CMD, CMD, POST_CMD, etc. */
        if (pr_stash_add_symbol(PR_SYM_CMD, cmdtab) < 0) {
          return -1;
        }
      }
    }
  }

  return 0;
}

int pr_module_load_conftab(module *m) {
  if (m == NULL ||
      m->name == NULL) {
    errno = EINVAL;
    return -1;
  }

  if (m->conftable) {
    conftable *conftab;

    for (conftab = m->conftable; conftab->directive; conftab++) {
      conftab->m = m;

      if (pr_stash_add_symbol(PR_SYM_CONF, conftab) < 0) {
        return -1;
      }
    }
  }

  return 0;
}

int pr_module_load(module *m) {
  char buf[256];

  if (m == NULL ||
      m->name == NULL) {
    errno = EINVAL;
    return -1;
  }

  /* Check the API version the module wants to use. */
  if (m->api_version < PR_MODULE_API_VERSION) {
    errno = EACCES;
    return -1;
  }

  /* Do not allow multiple modules with the same name. */
  memset(buf, '\0', sizeof(buf));
  pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);
  buf[sizeof(buf)-1] = '\0';

  if (pr_module_get(buf) != NULL) {
    errno = EEXIST;
    return -1;
  }

  /* Invoke the module's initialization routine. */
  if (!m->init ||
      m->init() >= 0) {

    /* Assign a priority to this module. */
    m->priority = curr_module_pri++;

    /* Add the module's config, cmd, and auth tables. */
    if (pr_module_load_conftab(m) < 0) {
      return -1;
    }

    if (pr_module_load_cmdtab(m) < 0) {
      return -1;
    }

    if (pr_module_load_authtab(m) < 0) {
      return -1;
    }

    /* Add the module to the loaded_modules list. */
    if (loaded_modules) {
      m->next = loaded_modules;
      loaded_modules->prev = m;
    }

    loaded_modules = m;

    /* Generate an event. */
    pr_event_generate("core.module-load", buf);
    return 0;
  }

  errno = EPERM;
  return -1;
}

int pr_module_unload(module *m) {
  char buf[256];

  if (m == NULL ||
      m->name == NULL) {
    errno = EINVAL;
    return -1;
  }

  /* Make sure this module has been loaded.  We can't unload a module that
   * has not been loaded, now can we?
   */

  memset(buf, '\0', sizeof(buf));
  pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);
  buf[sizeof(buf)-1] = '\0';

  if (pr_module_get(buf) == NULL) {
    errno = ENOENT;
    return -1;
  }

  /* Generate an event. */
  pr_event_generate("core.module-unload", buf);

  /* Remove the module from the loaded_modules list. */
  if (m->prev) {
    m->prev->next = m->next;

  } else {
    /* This module is the start of the loaded_modules list (prev is NULL),
     * so we need to update that pointer, too.
     */
    loaded_modules = m->next;
  }

  if (m->next) {
    m->next->prev = m->prev;
  }

  m->prev = m->next = NULL;

  /* Remove the module's config, cmd, and auth tables. */
  if (m->conftable) {
    conftable *conftab;

    for (conftab = m->conftable; conftab->directive; conftab++) {
      pr_stash_remove_symbol(PR_SYM_CONF, conftab->directive, conftab->m);
    }
  }

  if (m->cmdtable) {
    cmdtable *cmdtab;

    for (cmdtab = m->cmdtable; cmdtab->command; cmdtab++) {
      if (cmdtab->cmd_type == HOOK) {
        pr_stash_remove_symbol(PR_SYM_HOOK, cmdtab->command, cmdtab->m);

      } else {
        /* All other cmd_types are for CMDs: PRE_CMD, CMD, POST_CMD, etc. */
        pr_stash_remove_symbol(PR_SYM_CMD, cmdtab->command, cmdtab->m);
      }
    }
  }

  if (m->authtable) {
    authtable *authtab;

    for (authtab = m->authtable; authtab->name; authtab++) {
      pr_stash_remove_symbol(PR_SYM_AUTH, authtab->name, authtab->m);
    }
  }

  /* Remove any callbacks that the module may have registered, i.e.:
   *
   * ctrls
   * events
   * timers
   *
   * Ideally we would also automatically unregister other callbacks that
   * the module may have registered, such as FSIO, NetIO, variables, and
   * response handlers.  However, these APIs do not yet allow for
   * removal of all callbacks for a given module.
   */

#ifdef PR_USE_CTRLS
  pr_ctrls_unregister(m, NULL);
#endif /* PR_USE_CTRLS */
  pr_event_unregister(m, NULL, NULL);
  pr_timer_remove(-1, m);

  return 0;
}

int modules_init(void) {
  register unsigned int i = 0;

  for (i = 0; static_modules[i]; i++) {
    module *m = static_modules[i];

    if (pr_module_load(m) < 0) {
      pr_log_pri(PR_LOG_WARNING, "fatal: unable to load module 'mod_%s.c': %s",
        m->name, strerror(errno));
      exit(1);
    }
  }

  return 0;
}

1	/*
2	* ProFTPD - FTP server daemon
3	* Copyright (c) 1997, 1998 Public Flood Software
4	* Copyright (c) 2001-2026 The ProFTPD Project team
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, see <https://www.gnu.org/licenses/>.
18	*
19	* As a special exemption, Public Flood Software/MacGyver aka Habeeb J. Dihu
20	* and other respective copyright holders give permission to link this program
21	* with OpenSSL, and distribute the resulting executable, without including
22	* the source code for OpenSSL in the source distribution.
23	*/
24
25	/* Module handling routines */
26
27	#include "conf.h"
28
29	extern module *static_modules[];
30	extern module *loaded_modules;
31
32	/* Currently running module */
33	module *curr_module = NULL;
34
35	/* Used to track the priority for loaded modules. */
36	static unsigned int curr_module_pri = 0;
37
38	static const char *trace_channel = "module";
39
40	modret_t pr_module_call(module m, modret_t (func)(cmd_rec *),	86✔
41	cmd_rec *cmd) {
42	modret_t *res;
43	module *prev_module = curr_module;	86✔
44
45	if (m == NULL \|\|	172✔
46	func == NULL \|\|	166✔
47	cmd == NULL) {
48	errno = EINVAL;	7✔
49	return NULL;	7✔
50	}
51
52	if (cmd->tmp_pool == NULL) {	79✔
53	cmd->tmp_pool = make_sub_pool(cmd->pool);	9✔
54	pr_pool_tag(cmd->tmp_pool, "Module call tmp_pool");	9✔
55	}
56
57	curr_module = m;	79✔
58	res = func(cmd);	79✔
59	curr_module = prev_module;	79✔
60
61	/* Note that we don't clear the pool here because the function may
62	* return data which resides in this pool.
63	*/
64	return res;	79✔
65	}
66
67	modret_t mod_create_data(cmd_rec cmd, void *d) {	29✔
68	modret_t *res;
69
70	if (cmd == NULL) {	29✔
71	errno = EINVAL;	1✔
72	return NULL;	1✔
73	}
74
75	res = pcalloc(cmd->tmp_pool, sizeof(modret_t));	28✔
76	res->data = d;	28✔
77
78	return res;	28✔
79	}
80
81	modret_t mod_create_ret(cmd_rec cmd, unsigned char err, const char *n,	75✔
82	const char *m) {
83	modret_t *res;
84
85	if (cmd == NULL) {	75✔
86	errno = EINVAL;	1✔
87	return NULL;	1✔
88	}
89
90	res = pcalloc(cmd->tmp_pool, sizeof(modret_t));	74✔
91	res->mr_handler_module = curr_module;	74✔
92	res->mr_error = err;	74✔
93
94	if (n != NULL) {	74✔
95	res->mr_numeric = pstrdup(cmd->tmp_pool, n);	1✔
96	}
97
98	if (m != NULL) {	74✔
99	res->mr_message = pstrdup(cmd->tmp_pool, m);	54✔
100	}
101
102	return res;
103	}
104
105	modret_t mod_create_error(cmd_rec cmd, int mr_errno) {	20✔
106	modret_t *res;
107
108	if (cmd == NULL) {	20✔
109	errno = EINVAL;	1✔
110	return NULL;	1✔
111	}
112
113	res = pcalloc(cmd->tmp_pool, sizeof(modret_t));	19✔
114	res->mr_handler_module = curr_module;	19✔
115	res->mr_error = mr_errno;	19✔
116
117	return res;	19✔
118	}
119
120	/* Called after forking in order to inform/initialize modules
121	* need to know we are a child and have a connection.
122	*/
123	int modules_session_init(void) {	4✔
124	module prev_module = curr_module, m;	4✔
125
126	for (m = loaded_modules; m; m = m->next) {	6✔
127	if (m->sess_init) {	3✔
128	curr_module = m;	2✔
129
130	pr_trace_msg(trace_channel, 12,	2✔
131	"invoking sess_init callback on mod_%s.c", m->name);
132	if (m->sess_init() < 0) {	2✔
133	int xerrno = errno;	1✔
134
135	pr_log_pri(PR_LOG_WARNING,	1✔
136	"mod_%s.c: error initializing session (%s), check module logs "
137	"for details", m->name, strerror(xerrno));
138
139	errno = xerrno;	1✔
140	return -1;	1✔
141	}
142	}
143	}
144
145	curr_module = prev_module;	3✔
146	return 0;	3✔
147	}
148
149	unsigned char command_exists(const char *name) {	1✔
150	int idx = -1;	1✔
151	unsigned int hash = 0;	1✔
152	cmdtable *cmdtab;
153
154	cmdtab = pr_stash_get_symbol2(PR_SYM_CMD, name, NULL, &idx, &hash);	1✔
155	while (cmdtab && cmdtab->cmd_type != CMD) {	2✔
156	pr_signals_handle();	×
157	cmdtab = pr_stash_get_symbol2(PR_SYM_CMD, name, cmdtab, &idx, &hash);	×
158	}
159
160	return (cmdtab ? TRUE : FALSE);	1✔
161	}
162
163	unsigned char pr_module_exists(const char *name) {	5✔
164	return pr_module_get(name) != NULL ? TRUE : FALSE;	5✔
165	}
166
167	module pr_module_get(const char name) {	52✔
168	char buf[80] = {'\0'};	52✔
169	module *m;
170
171	if (name == NULL) {	52✔
172	errno = EINVAL;	2✔
173	return NULL;	2✔
174	}
175
176	/* Check the list of compiled-in modules. */
177	for (m = loaded_modules; m; m = m->next) {	58✔
178	memset(buf, '\0', sizeof(buf));	32✔
179	pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);	32✔
180	buf[sizeof(buf)-1] = '\0';	32✔
181
182	if (strcmp(buf, name) == 0) {	32✔
183	return m;
184	}
185	}
186
187	errno = ENOENT;	26✔
188	return NULL;	26✔
189	}
190
191	void modules_list2(int (listf)(const char , ...), int flags) {	4✔
192	if (listf == NULL) {	4✔
193	listf = printf;	1✔
194	}
195
196	if (flags & PR_MODULES_LIST_FL_SHOW_STATIC) {	4✔
197	register unsigned int i = 0;	2✔
198
199	listf("Compiled-in modules:\n");	2✔
200	for (i = 0; static_modules[i]; i++) {	2✔
201	module *m = static_modules[i];	×
202
203	if (flags & PR_MODULES_LIST_FL_SHOW_VERSION) {	×
204	const char *version;
205
206	version = m->module_version;	×
207	if (version != NULL) {	×
208	listf(" %s\n", version);	×
209
210	} else {
211	listf(" mod_%s.c\n", m->name);	×
212	}
213
214	} else {
215	listf(" mod_%s.c\n", m->name);	×
216	}
217	}
218
219	} else {
220	module *m;
221
222	listf("Loaded modules:\n");	2✔
223	for (m = loaded_modules; m; m = m->next) {	4✔
224
225	if (flags & PR_MODULES_LIST_FL_SHOW_VERSION) {	2✔
226	const char *version;
227
228	version = m->module_version;	2✔
229	if (version != NULL) {	2✔
230	listf(" %s\n", version);	1✔
231
232	} else {
233	listf(" mod_%s.c\n", m->name);	1✔
234	}
235
236	} else {
237	listf(" mod_%s.c\n", m->name);	×
238	}
239	}
240	}
241	}	4✔
242
243	void modules_list(int flags) {	1✔
244	modules_list2(NULL, flags);	1✔
245	}	1✔
246
247	int pr_module_load_authtab(module *m) {	7✔
248	if (m == NULL \|\|	13✔
249	m->name == NULL) {	6✔
250	errno = EINVAL;	2✔
251	return -1;	2✔
252	}
253
254	if (m->authtable) {	5✔
255	authtable *authtab;
256
257	for (authtab = m->authtable; authtab->name; authtab++) {	1✔
258	authtab->m = m;	1✔
259
260	if (pr_stash_add_symbol(PR_SYM_AUTH, authtab) < 0) {	1✔
261	return -1;
262	}
263	}
264	}
265
266	return 0;
267	}
268
269	int pr_module_load_cmdtab(module *m) {	7✔
270	if (m == NULL \|\|	13✔
271	m->name == NULL) {	6✔
272	errno = EINVAL;	2✔
273	return -1;	2✔
274	}
275
276	if (m->cmdtable) {	5✔
277	cmdtable *cmdtab;
278
279	for (cmdtab = m->cmdtable; cmdtab->command; cmdtab++) {	2✔
280	cmdtab->m = m;	2✔
281
282	if (cmdtab->cmd_type == HOOK) {	2✔
283	if (pr_stash_add_symbol(PR_SYM_HOOK, cmdtab) < 0) {	1✔
284	return -1;
285	}
286
287	} else {
288	/* All other cmd_types are for CMDs: PRE_CMD, CMD, POST_CMD, etc. */
289	if (pr_stash_add_symbol(PR_SYM_CMD, cmdtab) < 0) {	1✔
290	return -1;
291	}
292	}
293	}
294	}
295
296	return 0;
297	}
298
299	int pr_module_load_conftab(module *m) {	9✔
300	if (m == NULL \|\|	17✔
301	m->name == NULL) {	8✔
302	errno = EINVAL;	2✔
303	return -1;	2✔
304	}
305
306	if (m->conftable) {	7✔
307	conftable *conftab;
308
309	for (conftab = m->conftable; conftab->directive; conftab++) {	5✔
310	conftab->m = m;	5✔
311
312	if (pr_stash_add_symbol(PR_SYM_CONF, conftab) < 0) {	5✔
313	return -1;
314	}
315	}
316	}
317
318	return 0;
319	}
320
321	int pr_module_load(module *m) {	8✔
322	char buf[256];
323
324	if (m == NULL \|\|	15✔
325	m->name == NULL) {	7✔
326	errno = EINVAL;	2✔
327	return -1;	2✔
328	}
329
330	/* Check the API version the module wants to use. */
331	if (m->api_version < PR_MODULE_API_VERSION) {	6✔
332	errno = EACCES;	1✔
333	return -1;	1✔
334	}
335
336	/* Do not allow multiple modules with the same name. */
337	memset(buf, '\0', sizeof(buf));	5✔
338	pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);	5✔
339	buf[sizeof(buf)-1] = '\0';	5✔
340
341	if (pr_module_get(buf) != NULL) {	5✔
342	errno = EEXIST;	1✔
343	return -1;	1✔
344	}
345
346	/* Invoke the module's initialization routine. */
347	if (!m->init \|\|	5✔
348	m->init() >= 0) {	1✔
349
350	/* Assign a priority to this module. */
351	m->priority = curr_module_pri++;	3✔
352
353	/* Add the module's config, cmd, and auth tables. */
354	if (pr_module_load_conftab(m) < 0) {	3✔
355	return -1;
356	}
357
358	if (pr_module_load_cmdtab(m) < 0) {	3✔
359	return -1;
360	}
361
362	if (pr_module_load_authtab(m) < 0) {	3✔
363	return -1;
364	}
365
366	/* Add the module to the loaded_modules list. */
367	if (loaded_modules) {	3✔
368	m->next = loaded_modules;	×
369	loaded_modules->prev = m;	×
370	}
371
372	loaded_modules = m;	3✔
373
374	/* Generate an event. */
375	pr_event_generate("core.module-load", buf);	3✔
376	return 0;	3✔
377	}
378
379	errno = EPERM;	1✔
380	return -1;	1✔
381	}
382
383	int pr_module_unload(module *m) {	16✔
384	char buf[256];
385
386	if (m == NULL \|\|	31✔
387	m->name == NULL) {	15✔
388	errno = EINVAL;	2✔
389	return -1;	2✔
390	}
391
392	/* Make sure this module has been loaded. We can't unload a module that
393	* has not been loaded, now can we?
394	*/
395
396	memset(buf, '\0', sizeof(buf));	14✔
397	pr_snprintf(buf, sizeof(buf), "mod_%s.c", m->name);	14✔
398	buf[sizeof(buf)-1] = '\0';	14✔
399
400	if (pr_module_get(buf) == NULL) {	14✔
401	errno = ENOENT;	10✔
402	return -1;	10✔
403	}
404
405	/* Generate an event. */
406	pr_event_generate("core.module-unload", buf);	4✔
407
408	/* Remove the module from the loaded_modules list. */
409	if (m->prev) {	4✔
410	m->prev->next = m->next;	×
411
412	} else {
413	/* This module is the start of the loaded_modules list (prev is NULL),
414	* so we need to update that pointer, too.
415	*/
416	loaded_modules = m->next;	4✔
417	}
418
419	if (m->next) {	4✔
420	m->next->prev = m->prev;	×
421	}
422
423	m->prev = m->next = NULL;	4✔
424
425	/* Remove the module's config, cmd, and auth tables. */
426	if (m->conftable) {	4✔
427	conftable *conftab;
428
429	for (conftab = m->conftable; conftab->directive; conftab++) {	1✔
430	pr_stash_remove_symbol(PR_SYM_CONF, conftab->directive, conftab->m);	1✔
431	}
432	}
433
434	if (m->cmdtable) {	4✔
435	cmdtable *cmdtab;
436
437	for (cmdtab = m->cmdtable; cmdtab->command; cmdtab++) {	2✔
438	if (cmdtab->cmd_type == HOOK) {	2✔
439	pr_stash_remove_symbol(PR_SYM_HOOK, cmdtab->command, cmdtab->m);	1✔
440
441	} else {
442	/* All other cmd_types are for CMDs: PRE_CMD, CMD, POST_CMD, etc. */
443	pr_stash_remove_symbol(PR_SYM_CMD, cmdtab->command, cmdtab->m);	1✔
444	}
445	}
446	}
447
448	if (m->authtable) {	4✔
449	authtable *authtab;
450
451	for (authtab = m->authtable; authtab->name; authtab++) {	1✔
452	pr_stash_remove_symbol(PR_SYM_AUTH, authtab->name, authtab->m);	1✔
453	}
454	}
455
456	/* Remove any callbacks that the module may have registered, i.e.:
457	*
458	* ctrls
459	* events
460	* timers
461	*
462	* Ideally we would also automatically unregister other callbacks that
463	* the module may have registered, such as FSIO, NetIO, variables, and
464	* response handlers. However, these APIs do not yet allow for
465	* removal of all callbacks for a given module.
466	*/
467
468	#ifdef PR_USE_CTRLS
469	pr_ctrls_unregister(m, NULL);	4✔
470	#endif /* PR_USE_CTRLS */
471	pr_event_unregister(m, NULL, NULL);	4✔
472	pr_timer_remove(-1, m);	4✔
473
474	return 0;	4✔
475	}
476
477	int modules_init(void) {	25✔
478	register unsigned int i = 0;	25✔
479
480	for (i = 0; static_modules[i]; i++) {	25✔
481	module *m = static_modules[i];	×
482
483	if (pr_module_load(m) < 0) {	×
484	pr_log_pri(PR_LOG_WARNING, "fatal: unable to load module 'mod_%s.c': %s",	×
485	m->name, strerror(errno));	×
486	exit(1);	×
487	}
488	}
489
490	return 0;	25✔
491	}

proftpd / proftpd / 28531645955

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous