free guards

Author: braindigitalis

src/fs/fat32/main.c

@@ -60,10 +60,15 @@ int read_fat(fat32_t* info)
 	info->numberoffats = par->numberoffats;
 	info->fatsize = par->sectorsperfat;
 	info->info = kmalloc(sizeof(fat32_fs_info_t));
+	if (!info->info) {
+		kfree_null(&buffer);
+		return 0;
+	}
 	info->clustersize = par->sectorspercluster;
 	info->clustersize *= sd->block_size;
 
 	if (info->clustersize == 0) {
+		kfree_null(&buffer);
 		fs_set_error(FS_ERR_IS_EXFAT);
 		return 0;
 	}

src/fs/filesystem.c

@@ -178,6 +178,9 @@ bool vfs_path_add_child(const char* path, const char* child) {
 	}
 	if (exists->child_count == 0) {
 		exists->children = kmalloc(sizeof(char*));
+		if (!exists->children) {
+			return false;
+		}
 		exists->children[0] = strdup(child);
 		exists->child_count = 1;
 	} else {
@@ -196,6 +199,9 @@ bool vfs_path_add_child(const char* path, const char* child) {
 		}
 		exists->child_count++;
 		exists->children[exists->child_count - 1] = strdup(child);
+		if (!exists->children[exists->child_count - 1]) {
+			return false;
+		}
 	}
 	return true;
 }
@@ -662,6 +668,9 @@ fs_directory_entry_t* fs_create_directory(const char* pathandfile)
 		if (lbapos) {
 			dprintf("Driver createdirectory %lu\n", lbapos);
 			new_entry = kmalloc(sizeof(fs_directory_entry_t));
+			if (!new_entry) {
+				return NULL;
+			}
 			datetime_t dt;
 			get_datetime(&dt);
 			get_weekday_from_date(&dt);
@@ -683,6 +692,10 @@ fs_directory_entry_t* fs_create_directory(const char* pathandfile)
 			directory->files = new_entry;
 			/* TODO add to FS tree, dont forget responsible_driver ptr! */
 			fs_tree_t* new_dir  = kmalloc(sizeof(fs_tree_t));
+			if (!new_dir) {
+				kfree_null(&new_entry);
+				return NULL;
+			}
 			new_dir->next = directory->child_dirs;
 			new_dir->device = directory->device;
 			strlcpy(new_dir->device_name, directory->device_name, 16);

src/fs/iso9660.c

@@ -40,6 +40,9 @@ int parse_pvd(iso9660 *info, unsigned char *buffer) {
 
 	size_t j = 0;
 	info->volume_name = kmalloc(strlen(pvd->volumeidentifier) + 1);
+	if (!info->volume_name) {
+		return false;
+	}
 	for (ptr = pvd->volumeidentifier; *ptr && j < strlen(pvd->volumeidentifier); ++ptr) {
 		info->volume_name[j++] = *ptr;
 	}
@@ -363,6 +366,9 @@ int iso9660_attach(const char *device, const char *path) {
 
 void init_iso9660() {
 	iso9660_fs = kmalloc(sizeof(filesystem_t));
+	if (!iso9660_fs) {
+		return;
+	}
 	strlcpy(iso9660_fs->name, "iso9660", 31);
 	iso9660_fs->mount = iso9660_attach;
 	iso9660_fs->getdir = iso_get_directory;

src/fs/retrofs/getdirectory.c

@@ -43,6 +43,9 @@ fs_directory_entry_t *rfs_walk_directory(fs_tree_t *tree, rfs_t *info, uint64_t
 			}
 			/* Process entry */
 			fs_directory_entry_t *file = kmalloc(sizeof(fs_directory_entry_t));
+			if (!file) {
+				return NULL;
+			}
 			file->filename = strdup(entry->filename);
 			file->alt_filename = strdup(entry->filename);
 			file->lbapos = entry->sector_start;

src/installer/gpt_writer.c

@@ -218,6 +218,9 @@ bool prepare_rfs_partition(storage_device_t* dev) {
 	uint8_t partitionid = 0;
 	char found_guid[64];
 	rfs_t *info = kmalloc(sizeof(rfs_t));
+	if (!info) {
+		return false;
+	}
 	memset(info, 0, sizeof(rfs_t));
 	uint64_t start = 0, length = 0;
 	info->dev = dev;

src/installer/recursive_file_copy.c

@@ -12,6 +12,9 @@ bool copy_file(const char* source, const char* destination) {
 	fs_directory_entry_t* info = fs_get_file_info(source);
 	if (info && !(info->flags & FS_DIRECTORY) && info->size > 0) {
 		void *file_contents = kmalloc(info->size);
+		if (!file_contents) {
+			return false;
+		}
 		bool read_success = fs_read_file(info, 0, info->size, file_contents);
 		if (!read_success) {
 			error_page("Error reading '%s' (%s)\n", source, fs_strerror(fs_get_error()));

src/net/ip.c

@@ -538,6 +538,10 @@ void ip_handle_packet(ip_packet_t* packet, [[maybe_unused]] int n_len) {
 				/* We have complete packet, all fragments - reassemble the data part and free everything */
 				ip_packet_frag_t* cur = fragmented->ordered_list;
 				data_ptr = kmalloc(fragmented->size);
+				if (!data_ptr) {
+					dprintf("Can't allocate memory for frag\n");
+					return;
+				}
 				data_len = fragmented->size;
 				/* Set flag to indicate we need to free the data_ptr later */
 				fragment_to_free = true;

src/net/queue.c

@@ -2,27 +2,38 @@
 
 inline queue_t* queue_new(void) {
 	queue_t *q = kmalloc(sizeof(queue_t));
-	if (!q) return NULL;
+	if (!q) {
+		return NULL;
+	}
 	q->head = q->tail = NULL;
 	return q;
 }
 
 inline void queue_push(queue_t *q, tcp_conn_t *conn) {
 	pending_node_t *n = kmalloc(sizeof(pending_node_t));
-	if (!n) return;
+	if (!n) {
+		return;
+	}
 	n->conn = conn;
 	n->next = NULL;
-	if (q->tail) q->tail->next = n;
-	else q->head = n;
+	if (q->tail) {
+		q->tail->next = n;
+	} else {
+		q->head = n;
+	}
 	q->tail = n;
 }
 
 inline tcp_conn_t* queue_pop(queue_t *q) {
-	if (!q || !q->head) return NULL;
+	if (!q || !q->head) {
+		return NULL;
+	}
 	pending_node_t *n = q->head;
 	tcp_conn_t *c = n->conn;
 	q->head = n->next;
-	if (!q->head) q->tail = NULL;
+	if (!q->head) {
+		q->tail = NULL;
+	}
 	kfree_null(&n);
 	return c;
 }

src/net/tcp.c

@@ -291,6 +291,9 @@ tcp_conn_t* tcp_send_segment(tcp_conn_t *conn, uint32_t seq, uint8_t flags, cons
 	tcp_options_t options = { .mss = flags & TCP_SYN ? 1460 : 0 };
 	uint16_t length = sizeof(tcp_segment_t) + count + (flags & TCP_SYN ? 4 : 0);
 	tcp_segment_t* packet = kmalloc(length);
+	if (!packet) {
+		return NULL;
+	}
 
 	memset(packet, 0, length);
 	packet->src_port = conn->local_port;
@@ -441,7 +444,14 @@ tcp_segment_t* tcp_ord_list_insert(tcp_conn_t* conn, tcp_segment_t* segment, siz
 
 	// allocate new node
 	tcp_ordered_list_t *new = kmalloc(sizeof(tcp_ordered_list_t));
+	if (!new) {
+		return NULL;
+	}
 	new->segment = kmalloc(len + tcp_header_size(segment));
+	if (!new->segment) {
+		kfree_null(&new);
+		return NULL;
+	}
 	memcpy(new->segment, segment, len + tcp_header_size(segment));
 	new->len = len;
 	new->prev = NULL;

src/rtl8139.c

@@ -306,8 +306,6 @@ void init_rtl8139() {
 
 	rtl_outl(RxBuf, rtl8139_device.rx_buffer);
 
-	kprintf("RX buffer assigned at %08x\n", rtl8139_device.rx_buffer);
-
 	rtl_outb(RxEarlyThresh, 0x3C);
 
 	for(int i=0; i < 4; i++) {
@@ -341,6 +339,9 @@ void init_rtl8139() {
 	make_unique_device_name("net", rtl8139_device.name, sizeof(rtl8139_device.name));
 
 	netdev_t* net = kmalloc(sizeof(netdev_t));
+	if (!net) {
+		return;
+	}
 	net->opaque = &rtl8139_device;
 	net->deviceid = (RTL8139_VENDOR_ID << 16) | RTL8139_DEVICE_ID;
 	strlcpy(net->name, rtl8139_device.name, 16);