code
stringlengths 14
2.05k
| label
int64 0
1
| programming_language
stringclasses 7
values | cwe_id
stringlengths 6
14
| cwe_name
stringlengths 5
98
⌀ | description
stringlengths 36
379
⌀ | url
stringlengths 36
48
⌀ | label_name
stringclasses 2
values |
|---|---|---|---|---|---|---|---|
render_pixbuf_size_prepared_cb (GdkPixbufLoader *loader,
gint width,
gint height,
gpointer data)
{
double *scale = data;
int w = (width * (*scale) + 0.5);
int h = (height * (*scale) + 0.5);
gdk_pixbuf_loader_set_size (loader, w, h);
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_generate_command_lines (ComicsDocument *comics_document,
GError **error)
{
gchar *quoted_file, *quoted_file_aux;
gchar *quoted_command;
ComicBookDecompressType type;
type = comics_document->command_usage;
comics_document->regex_arg = command_usage_def[type].regex_arg;
quoted_command = g_shell_quote (comics_document->selected_command);
if (comics_document->regex_arg) {
quoted_file = comics_regex_quote (comics_document->archive);
quoted_file_aux = g_shell_quote (comics_document->archive);
comics_document->list_command =
g_strdup_printf (command_usage_def[type].list,
comics_document->alternative_command,
quoted_file_aux);
g_free (quoted_file_aux);
} else {
quoted_file = g_shell_quote (comics_document->archive);
comics_document->list_command =
g_strdup_printf (command_usage_def[type].list,
quoted_command, quoted_file);
}
comics_document->extract_command =
g_strdup_printf (command_usage_def[type].extract,
quoted_command);
comics_document->offset = command_usage_def[type].offset;
if (command_usage_def[type].decompress_tmp) {
comics_document->dir = ev_mkdtemp ("atril-comics-XXXXXX", error);
if (comics_document->dir == NULL)
return FALSE;
/* unrar-free can't create directories, but ev_mkdtemp already created the dir */
comics_document->decompress_tmp =
g_strdup_printf (command_usage_def[type].decompress_tmp,
quoted_command, quoted_file,
comics_document->dir);
g_free (quoted_file);
g_free (quoted_command);
if (!comics_decompress_temp_dir (comics_document->decompress_tmp,
comics_document->selected_command, error))
return FALSE;
else
return TRUE;
} else {
g_free (quoted_file);
g_free (quoted_command);
return TRUE;
}
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_document_init (ComicsDocument *comics_document)
{
comics_document->archive = NULL;
comics_document->page_names = NULL;
comics_document->extract_command = NULL;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
get_page_size_area_prepared_cb (GdkPixbufLoader *loader,
gpointer data)
{
gboolean *got_size = data;
*got_size = TRUE;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_remove_dir (gchar *path_name)
{
GDir *content_dir;
const gchar *filename;
gchar *filename_with_path;
if (g_file_test (path_name, G_FILE_TEST_IS_DIR)) {
content_dir = g_dir_open (path_name, 0, NULL);
filename = g_dir_read_name (content_dir);
while (filename) {
filename_with_path =
g_build_filename (path_name,
filename, NULL);
comics_remove_dir (filename_with_path);
g_free (filename_with_path);
filename = g_dir_read_name (content_dir);
}
g_dir_close (content_dir);
}
/* Note from g_remove() documentation: on Windows, it is in general not
* possible to remove a file that is open to some process, or mapped
* into memory.*/
return (g_remove (path_name));
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_document_finalize (GObject *object)
{
ComicsDocument *comics_document = COMICS_DOCUMENT (object);
if (comics_document->decompress_tmp) {
if (comics_remove_dir (comics_document->dir) == -1)
g_warning (_("There was an error deleting “%s”."),
comics_document->dir);
g_free (comics_document->dir);
}
if (comics_document->page_names) {
g_ptr_array_foreach (comics_document->page_names, (GFunc) g_free, NULL);
g_ptr_array_free (comics_document->page_names, TRUE);
}
g_free (comics_document->archive);
g_free (comics_document->selected_command);
g_free (comics_document->alternative_command);
g_free (comics_document->extract_command);
g_free (comics_document->list_command);
G_OBJECT_CLASS (comics_document_parent_class)->finalize (object);
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_document_render (EvDocument *document,
EvRenderContext *rc)
{
GdkPixbuf *pixbuf;
cairo_surface_t *surface;
pixbuf = comics_document_render_pixbuf (document, rc);
surface = ev_document_misc_surface_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
return surface;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
sort_page_names (gconstpointer a,
gconstpointer b)
{
const char *name_1, *name_2;
gchar *key_1, *key_2;
gboolean sort_last_1, sort_last_2;
int compare;
name_1 = * (const char **) a;
name_2 = * (const char **) b;
#define SORT_LAST_CHAR1 '.'
#define SORT_LAST_CHAR2 '#'
sort_last_1 = name_1[0] == SORT_LAST_CHAR1 || name_1[0] == SORT_LAST_CHAR2;
sort_last_2 = name_2[0] == SORT_LAST_CHAR1 || name_2[0] == SORT_LAST_CHAR2;
#undef SORT_LAST_CHAR1
#undef SORT_LAST_CHAR2
if (sort_last_1 && !sort_last_2)
{
compare = +1;
}
else if (!sort_last_1 && sort_last_2)
{
compare = -1;
}
else
{
key_1 = g_utf8_collate_key_for_filename (name_1, -1);
key_2 = g_utf8_collate_key_for_filename (name_2, -1);
compare = strcmp (key_1, key_2);
g_free (key_1);
g_free (key_2);
}
return compare;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
get_supported_image_extensions(void)
{
GSList *extensions = NULL;
GSList *formats = gdk_pixbuf_get_formats ();
GSList *l;
for (l = formats; l != NULL; l = l->next) {
int i;
gchar **ext = gdk_pixbuf_format_get_extensions (l->data);
for (i = 0; ext[i] != NULL; i++) {
extensions = g_slist_append (extensions,
g_strdup (ext[i]));
}
g_strfreev (ext);
}
g_slist_free (formats);
return extensions;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_decompress_temp_dir (const gchar *command_decompress_tmp,
const gchar *command,
GError **error)
{
gboolean success;
gchar *std_out, *basename;
GError *err = NULL;
gint retval;
success = g_spawn_command_line_sync (command_decompress_tmp, &std_out,
NULL, &retval, &err);
basename = g_path_get_basename (command);
if (!success) {
g_set_error (error,
EV_DOCUMENT_ERROR,
EV_DOCUMENT_ERROR_INVALID,
_("Error launching the command “%s” in order to "
"decompress the comic book: %s"),
basename,
err->message);
g_error_free (err);
} else if (WIFEXITED (retval)) {
if (WEXITSTATUS (retval) == EXIT_SUCCESS) {
g_free (std_out);
g_free (basename);
return TRUE;
} else {
g_set_error (error,
EV_DOCUMENT_ERROR,
EV_DOCUMENT_ERROR_INVALID,
_("The command “%s” failed at "
"decompressing the comic book."),
basename);
g_free (std_out);
}
} else {
g_set_error (error,
EV_DOCUMENT_ERROR,
EV_DOCUMENT_ERROR_INVALID,
_("The command “%s” did not end normally."),
basename);
g_free (std_out);
}
g_free (basename);
return FALSE;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_document_get_page_size (EvDocument *document,
EvPage *page,
double *width,
double *height)
{
GdkPixbufLoader *loader;
char **argv;
guchar buf[1024];
gboolean success, got_size = FALSE;
gint outpipe = -1;
GPid child_pid;
gssize bytes;
GdkPixbuf *pixbuf;
gchar *filename;
ComicsDocument *comics_document = COMICS_DOCUMENT (document);
if (!comics_document->decompress_tmp) {
argv = extract_argv (document, page->index);
success = g_spawn_async_with_pipes (NULL, argv, NULL,
G_SPAWN_SEARCH_PATH |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, NULL,
&child_pid,
NULL, &outpipe, NULL, NULL);
g_strfreev (argv);
g_return_if_fail (success == TRUE);
loader = gdk_pixbuf_loader_new ();
g_signal_connect (loader, "area-prepared",
G_CALLBACK (get_page_size_area_prepared_cb),
&got_size);
while (outpipe >= 0) {
bytes = read (outpipe, buf, 1024);
if (bytes > 0)
gdk_pixbuf_loader_write (loader, buf, bytes, NULL);
if (bytes <= 0 || got_size) {
close (outpipe);
outpipe = -1;
gdk_pixbuf_loader_close (loader, NULL);
}
}
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
if (pixbuf) {
if (width)
*width = gdk_pixbuf_get_width (pixbuf);
if (height)
*height = gdk_pixbuf_get_height (pixbuf);
}
g_spawn_close_pid (child_pid);
g_object_unref (loader);
} else {
filename = g_build_filename (comics_document->dir,
(char *) comics_document->page_names->pdata[page->index],
NULL);
pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
if (pixbuf) {
if (width)
*width = gdk_pixbuf_get_width (pixbuf);
if (height)
*height = gdk_pixbuf_get_height (pixbuf);
g_object_unref (pixbuf);
}
g_free (filename);
}
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
extract_argv (EvDocument *document, gint page)
{
ComicsDocument *comics_document = COMICS_DOCUMENT (document);
char **argv;
char *command_line, *quoted_archive, *quoted_filename;
GError *err = NULL;
if (g_strrstr (comics_document->page_names->pdata[page], "--checkpoint-action="))
{
g_warning ("File unsupported\n");
gtk_main_quit ();
}
if (page >= comics_document->page_names->len)
return NULL;
if (comics_document->regex_arg) {
quoted_archive = g_shell_quote (comics_document->archive);
quoted_filename =
comics_regex_quote (comics_document->page_names->pdata[page]);
} else {
quoted_archive = g_shell_quote (comics_document->archive);
quoted_filename = g_shell_quote (comics_document->page_names->pdata[page]);
}
command_line = g_strdup_printf ("%s %s %s",
comics_document->extract_command,
quoted_archive,
quoted_filename);
g_free (quoted_archive);
g_free (quoted_filename);
g_shell_parse_argv (command_line, NULL, &argv, &err);
g_free (command_line);
if (err) {
g_warning (_("Error %s"), err->message);
g_error_free (err);
return NULL;
}
return argv;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_regex_quote (const gchar *unquoted_string)
{
const gchar *p;
GString *dest;
dest = g_string_new ("'");
p = unquoted_string;
while (*p) {
switch (*p) {
/* * matches a sequence of 0 or more characters */
case ('*'):
/* ? matches exactly 1 charactere */
case ('?'):
/* [...] matches any single character found inside
* the brackets. Disabling the first bracket is enough.
*/
case ('['):
g_string_append (dest, "[");
g_string_append_c (dest, *p);
g_string_append (dest, "]");
break;
/* Because \ escapes regex expressions that we are
* disabling for unzip, we need to disable \ too */
case ('\\'):
g_string_append (dest, "[\\\\]");
break;
/* Escape single quote inside the string */
case ('\''):
g_string_append (dest, "'\\''");
break;
default:
g_string_append_c (dest, *p);
break;
}
++p;
}
g_string_append_c (dest, '\'');
return g_string_free (dest, FALSE);
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
comics_document_render_pixbuf (EvDocument *document,
EvRenderContext *rc)
{
GdkPixbufLoader *loader;
GdkPixbuf *rotated_pixbuf, *tmp_pixbuf;
char **argv;
guchar buf[4096];
gboolean success;
gint outpipe = -1;
GPid child_pid;
gssize bytes;
gint width, height;
gchar *filename;
ComicsDocument *comics_document = COMICS_DOCUMENT (document);
if (!comics_document->decompress_tmp) {
argv = extract_argv (document, rc->page->index);
success = g_spawn_async_with_pipes (NULL, argv, NULL,
G_SPAWN_SEARCH_PATH |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, NULL,
&child_pid,
NULL, &outpipe, NULL, NULL);
g_strfreev (argv);
g_return_val_if_fail (success == TRUE, NULL);
loader = gdk_pixbuf_loader_new ();
g_signal_connect (loader, "size-prepared",
G_CALLBACK (render_pixbuf_size_prepared_cb),
&rc->scale);
while (outpipe >= 0) {
bytes = read (outpipe, buf, 4096);
if (bytes > 0) {
gdk_pixbuf_loader_write (loader, buf, bytes,
NULL);
} else {
close (outpipe);
gdk_pixbuf_loader_close (loader, NULL);
outpipe = -1;
}
}
tmp_pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
rotated_pixbuf =
gdk_pixbuf_rotate_simple (tmp_pixbuf,
360 - rc->rotation);
g_spawn_close_pid (child_pid);
g_object_unref (loader);
} else {
filename =
g_build_filename (comics_document->dir,
(char *) comics_document->page_names->pdata[rc->page->index],
NULL);
gdk_pixbuf_get_file_info (filename, &width, &height);
tmp_pixbuf =
gdk_pixbuf_new_from_file_at_size (
filename, width * (rc->scale) + 0.5,
height * (rc->scale) + 0.5, NULL);
rotated_pixbuf =
gdk_pixbuf_rotate_simple (tmp_pixbuf,
360 - rc->rotation);
g_free (filename);
g_object_unref (tmp_pixbuf);
}
return rotated_pixbuf;
} | 0 | C | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The product constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
static int set_expected_hash(const char *val, const struct kernel_param *kp)
{
int rv = param_set_uint(val, kp);
ksu_invalidate_manager_uid();
pr_info("ksu_expected_hash set to %x\n", ksu_expected_hash);
return rv;
} | 0 | C | CWE-863 | Incorrect Authorization | The product performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check. This allows attackers to bypass intended access restrictions. | https://cwe.mitre.org/data/definitions/863.html | vulnerable |
int is_manager_apk(char *path)
{
return check_v2_signature(path, ksu_expected_size, ksu_expected_hash);
} | 0 | C | CWE-863 | Incorrect Authorization | The product performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check. This allows attackers to bypass intended access restrictions. | https://cwe.mitre.org/data/definitions/863.html | vulnerable |
static void fio_worker_cleanup(void) {
/* switch to winding down */
if (fio_data->is_worker)
FIO_LOG_INFO("(%d) detected exit signal.", (int)getpid());
else
FIO_LOG_INFO("Server Detected exit signal.");
fio_state_callback_force(FIO_CALL_ON_SHUTDOWN);
for (size_t i = 0; i <= fio_data->max_protocol_fd; ++i) {
if (fd_data(i).protocol) {
fio_defer_push_task(deferred_on_shutdown, (void *)fd2uuid(i), NULL);
}
}
fio_defer_push_task(fio_cycle_unwind, NULL, NULL);
fio_defer_perform();
for (size_t i = 0; i <= fio_data->max_protocol_fd; ++i) {
if (fd_data(i).protocol || fd_data(i).open) {
fio_force_close(fd2uuid(i));
}
}
fio_defer_perform();
fio_state_callback_force(FIO_CALL_ON_FINISH);
fio_defer_perform();
if (!fio_data->is_worker) {
fio_cluster_signal_children();
while (wait(NULL) != -1)
;
}
fio_defer_perform();
fio_signal_handler_reset();
if (fio_data->parent == getpid()) {
FIO_LOG_INFO(" --- Shutdown Complete ---\n");
} else {
FIO_LOG_INFO("(%d) cleanup complete.", (int)getpid());
}
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
void fio_signal_handler_reset(void) {
struct sigaction old;
if (!fio_old_sig_int.sa_handler)
return;
memset(&old, 0, sizeof(old));
sigaction(SIGINT, &fio_old_sig_int, &old);
sigaction(SIGTERM, &fio_old_sig_term, &old);
sigaction(SIGPIPE, &fio_old_sig_pipe, &old);
if (fio_old_sig_chld.sa_handler)
sigaction(SIGCHLD, &fio_old_sig_chld, &old);
#if !FIO_DISABLE_HOT_RESTART
sigaction(SIGUSR1, &fio_old_sig_usr1, &old);
memset(&fio_old_sig_usr1, 0, sizeof(fio_old_sig_usr1));
#endif
memset(&fio_old_sig_int, 0, sizeof(fio_old_sig_int));
memset(&fio_old_sig_term, 0, sizeof(fio_old_sig_term));
memset(&fio_old_sig_pipe, 0, sizeof(fio_old_sig_pipe));
memset(&fio_old_sig_chld, 0, sizeof(fio_old_sig_chld));
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void fio_cluster_signal_children(void) {
if (fio_parent_pid() != getpid()) {
fio_stop();
return;
}
fio_cluster_server_sender(fio_msg_internal_create(0, FIO_CLUSTER_MSG_SHUTDOWN,
(fio_str_info_s){.len = 0},
(fio_str_info_s){.len = 0},
0, 1),
-1);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void fio_cluster_listen_on_close(intptr_t uuid,
fio_protocol_s *protocol) {
free(protocol);
cluster_data.uuid = -1;
if (fio_parent_pid() == getpid()) {
#if DEBUG
FIO_LOG_DEBUG("(%d) stopped listening for cluster connections",
(int)getpid());
#endif
if (fio_data->active)
fio_stop();
}
(void)uuid;
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void fio_signal_handler_setup(void) {
/* setup signal handling */
struct sigaction act;
if (fio_old_sig_int.sa_handler)
return;
memset(&act, 0, sizeof(act));
act.sa_handler = sig_int_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_RESTART | SA_NOCLDSTOP;
if (sigaction(SIGINT, &act, &fio_old_sig_int)) {
perror("couldn't set signal handler");
return;
};
if (sigaction(SIGTERM, &act, &fio_old_sig_term)) {
perror("couldn't set signal handler");
return;
};
#if !FIO_DISABLE_HOT_RESTART
if (sigaction(SIGUSR1, &act, &fio_old_sig_usr1)) {
perror("couldn't set signal handler");
return;
};
#endif
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, &fio_old_sig_pipe)) {
perror("couldn't set signal handler");
return;
};
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void __attribute__((destructor)) fio_lib_destroy(void) {
uint8_t add_eol = fio_is_master();
fio_data->active = 0;
fio_on_fork();
fio_defer_perform();
fio_state_callback_force(FIO_CALL_AT_EXIT);
fio_state_callback_clear_all();
fio_defer_perform();
fio_poll_close();
fio_timer_clear_all();
fio_free(fio_data);
/* memory library destruction must be last */
fio_mem_destroy();
FIO_LOG_DEBUG("(%d) facil.io resources released, exit complete.",
(int)getpid());
if (add_eol)
fprintf(stderr, "\n"); /* add EOL to logs (logging adds EOL before text */
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static struct timespec fio_timer_calc_due(size_t interval) {
struct timespec now = fio_last_tick();
if (interval > 1000) {
now.tv_sec += interval / 1000;
interval -= interval / 1000;
}
now.tv_nsec += (interval * 1000000UL);
if (now.tv_nsec > 1000000000L) {
now.tv_nsec -= 1000000000L;
now.tv_sec += 1;
}
return now;
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void sig_int_handler(int sig) {
struct sigaction *old = NULL;
switch (sig) {
#if !FIO_DISABLE_HOT_RESTART
case SIGUSR1:
fio_signal_children_flag = 1;
old = &fio_old_sig_usr1;
break;
#endif
/* fallthrough */
case SIGINT:
if (!old)
old = &fio_old_sig_int;
/* fallthrough */
case SIGTERM:
if (!old)
old = &fio_old_sig_term;
fio_stop();
break;
case SIGPIPE:
if (!old)
old = &fio_old_sig_pipe;
/* fallthrough */
default:
break;
}
/* propagate signale handling to previous existing handler (if any) */
if (old->sa_handler != SIG_IGN && old->sa_handler != SIG_DFL)
old->sa_handler(sig);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
inline FIO_FUNC ssize_t fio_sendfile(intptr_t uuid, intptr_t source_fd,
off_t offset, size_t length) {
return fio_write2(uuid, .data.fd = source_fd, .length = length, .is_fd = 1,
.offset = offset);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
FIO_FUNC inline void fio_throttle_thread(size_t nano_sec) {
const struct timespec tm = {.tv_nsec = (nano_sec % 1000000000),
.tv_sec = (nano_sec / 1000000000)};
nanosleep(&tm, NULL);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static inline __attribute__((unused)) ssize_t fiobj_send_free(intptr_t uuid,
FIOBJ o) {
fio_str_info_s s = fiobj_obj2cstr(o);
return fio_write2(uuid, .data.buffer = (void *)(o),
.offset = (((intptr_t)s.data) - ((intptr_t)(o))),
.length = s.len, .after.dealloc = fiobj4sock_dealloc);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void http1_on_ready(intptr_t uuid, fio_protocol_s *protocol) {
/* resume slow clients from suspension */
http1pr_s *p = (http1pr_s *)protocol;
if ((p->stop & 4)) {
p->stop ^= 4;
fio_force_event(uuid, FIO_EVENT_ON_DATA);
}
(void)protocol;
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static int http1_on_response(http1_parser_s *parser) {
http1pr_s *p = parser2http(parser);
http_on_response_handler______internal(&http1_pr2handle(p), p->p.settings);
if (p->request.status_str && !p->stop)
http_finish(&p->request);
h1_reset(p);
return !p->close && fio_is_closed(p->p.uuid);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static inline void http1_consume_data(intptr_t uuid, http1pr_s *p) {
if (fio_pending(uuid) > 4) {
goto throttle;
}
ssize_t i = 0;
size_t org_len = p->buf_len;
int pipeline_limit = 8;
if (!p->buf_len)
return;
do {
i = http1_fio_parser(.parser = &p->parser,
.buffer = p->buf + (org_len - p->buf_len),
.length = p->buf_len, .on_request = http1_on_request,
.on_response = http1_on_response,
.on_method = http1_on_method,
.on_status = http1_on_status, .on_path = http1_on_path,
.on_query = http1_on_query,
.on_http_version = http1_on_http_version,
.on_header = http1_on_header,
.on_body_chunk = http1_on_body_chunk,
.on_error = http1_on_error);
p->buf_len -= i;
--pipeline_limit;
} while (i && p->buf_len && pipeline_limit && !p->stop);
if (p->buf_len && org_len != p->buf_len) {
memmove(p->buf, p->buf + (org_len - p->buf_len), p->buf_len);
}
if (p->buf_len == HTTP_MAX_HEADER_LENGTH) {
/* no room to read... parser not consuming data */
if (p->request.method)
http_send_error(&p->request, 413);
else {
p->request.method = fiobj_str_tmp();
http_send_error(&p->request, 413);
}
}
if (!pipeline_limit) {
fio_force_event(uuid, FIO_EVENT_ON_DATA);
}
return;
throttle:
/* throttle busy clients (slowloris) */
fio_suspend(uuid);
p->stop |= 4;
FIO_LOG_DEBUG("(HTTP/1,1) throttling client at %.*s",
(int)fio_peer_addr(uuid).len, fio_peer_addr(uuid).data);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void http1_on_data_first_time(intptr_t uuid, fio_protocol_s *protocol) {
http1pr_s *p = (http1pr_s *)protocol;
ssize_t i;
i = fio_read(uuid, p->buf + p->buf_len, HTTP_MAX_HEADER_LENGTH - p->buf_len);
if (i <= 0)
return;
p->buf_len += i;
/* ensure future reads skip this first time HTTP/2.0 test */
p->p.protocol.on_data = http1_on_data;
/* Test fot HTTP/2.0 pre-knowledge */
if (i >= 24 && !memcmp(p->buf, "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", 24)) {
FIO_LOG_WARNING("client claimed unsupported HTTP/2 prior knowledge.");
fio_close(uuid);
return;
}
/* Finish handling the same way as the normal `on_data` */
http1_consume_data(uuid, p);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static int http1_on_error(http1_parser_s *parser) {
FIO_LOG_DEBUG("HTTP parser error at HTTP/1.1 buffer position %zu/%zu",
parser->state.next - parser2http(parser)->buf,
parser2http(parser)->buf_len);
fio_close(parser2http(parser)->p.uuid);
return -1;
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static int http1_on_request(http1_parser_s *parser) {
http1pr_s *p = parser2http(parser);
http_on_request_handler______internal(&http1_pr2handle(p), p->p.settings);
if (p->request.method && !p->stop)
http_finish(&p->request);
h1_reset(p);
return !p->close && fio_is_closed(p->p.uuid);
} | 0 | C | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
static void process_request(struct connection *conn) {
num_requests++;
if (!parse_request(conn)) {
default_reply(conn, 400, "Bad Request",
"You sent a request that the server couldn't understand.");
}
else if (is_https_redirect(conn)) {
redirect_https(conn);
}
/* fail if: (auth_enabled) AND (client supplied invalid credentials) */
else if (auth_key != NULL &&
(conn->authorization == NULL ||
strcmp(conn->authorization, auth_key)))
{
default_reply(conn, 401, "Unauthorized",
"Access denied due to invalid credentials.");
}
else if (strcmp(conn->method, "GET") == 0) {
process_get(conn);
}
else if (strcmp(conn->method, "HEAD") == 0) {
process_get(conn);
conn->header_only = 1;
}
else {
default_reply(conn, 501, "Not Implemented",
"The method you specified is not implemented.");
}
/* advance state */
conn->state = SEND_HEADER;
/* request not needed anymore */
free(conn->request);
conn->request = NULL; /* important: don't free it again later */
} | 0 | C | NVD-CWE-noinfo | null | null | null | vulnerable |