RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 21:27:35 +00:00
Code Issues Activity Actions

LibC: Use AK::String-backed buffers instead of static buffers

Browse source 
Also, refactor the hell out of pwd.cpp & grp.cpp
This commit is contained in:
Sergey Bugaev 2020-08-25 17:21:45 +03:00 • committed by Andreas Kling
parent 5fd88e51c5
commit 17109a3a31
4 changed files with 192 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

148
Libraries/LibC/grp.cpp
View file

@ -26,54 +26,51 @@
#include <AK/String.h>
#include <AK/Vector.h>
#include <errno_numbers.h>
#include <grp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
extern "C" {
#define GRDB_STR_MAX_LEN 256
static FILE* s_stream = nullptr;
static unsigned s_line_number = 0;
static struct group s_group;
struct group_with_strings : public group {
char name_buffer[GRDB_STR_MAX_LEN];
char passwd_buffer[GRDB_STR_MAX_LEN];
char* members[32];
char members_buffer[32][32];
};
static FILE* __grdb_stream = nullptr;
static unsigned __grdb_line_number = 0;
static struct group_with_strings* __grdb_entry = nullptr;
static String s_name;
static String s_passwd;
static Vector<String> s_members;
static Vector<const char*> s_members_ptrs;
void setgrent()
{
__grdb_line_number = 0;
if (__grdb_stream) {
rewind(__grdb_stream);
s_line_number = 0;
if (s_stream) {
rewind(s_stream);
} else {
__grdb_stream = fopen("/etc/group", "r");
if (!__grdb_stream) {
s_stream = fopen("/etc/group", "r");
if (!s_stream) {
perror("open /etc/group");
}
assert(__grdb_stream);
__grdb_entry = (struct group_with_strings*)mmap_with_name(nullptr, getpagesize(), PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0, "setgrent");
}
}
void endgrent()
{
__grdb_line_number = 0;
if (__grdb_stream) {
fclose(__grdb_stream);
__grdb_stream = nullptr;
}
if (__grdb_entry) {
munmap(__grdb_entry, getpagesize());
__grdb_entry = nullptr;
s_line_number = 0;
if (s_stream) {
fclose(s_stream);
s_stream = nullptr;
}
memset(&s_group, 0, sizeof(s_group));
s_name = {};
s_passwd = {};
s_members = {};
s_members_ptrs = {};
}
struct group* getgrgid(gid_t gid)
@ -96,52 +93,69 @@ struct group* getgrnam(const char* name)
return nullptr;
}
static bool parse_grpdb_entry(const String& line)
{
auto parts = line.split_view(':', true);
if (parts.size() != 4) {
fprintf(stderr, "getgrent(): Malformed entry on line %u: '%s' has %zu parts\n", s_line_number, line.characters(), parts.size());
return false;
}
s_name = parts[0];
s_passwd = parts[1];
auto& gid_string = parts[2];
String members_string = parts[3];
auto gid = gid_string.to_uint();
if (!gid.has_value()) {
fprintf(stderr, "getgrent(): Malformed GID on line %u\n", s_line_number);
return false;
}
s_members = members_string.split(',');
s_members_ptrs.clear_with_capacity();
s_members_ptrs.ensure_capacity(s_members.size() + 1);
for (auto& member : s_members) {
s_members_ptrs.append(member.characters());
}
s_members_ptrs.append(nullptr);
s_group.gr_gid = gid.value();
s_group.gr_name = const_cast<char*>(s_name.characters());
s_group.gr_passwd = const_cast<char*>(s_passwd.characters());
s_group.gr_mem = const_cast<char**>(s_members_ptrs.data());
return true;
}
struct group* getgrent()
{
if (!__grdb_stream)
if (!s_stream)
setgrent();
assert(__grdb_stream);
if (feof(__grdb_stream))
return nullptr;
while (true) {
if (!s_stream || feof(s_stream))
return nullptr;
next_entry:
char buffer[1024];
++__grdb_line_number;
char* s = fgets(buffer, sizeof(buffer), __grdb_stream);
if (!s)
return nullptr;
assert(__grdb_stream);
if (feof(__grdb_stream))
return nullptr;
String line(s, Chomp);
auto parts = line.split(':', true);
if (parts.size() != 4) {
fprintf(stderr, "getgrent(): Malformed entry on line %u: '%s' has %zu parts\n", __grdb_line_number, line.characters(), parts.size());
goto next_entry;
if (ferror(s_stream)) {
fprintf(stderr, "getgrent(): Read error: %s\n", strerror(ferror(s_stream)));
return nullptr;
}
char buffer[1024];
++s_line_number;
char* s = fgets(buffer, sizeof(buffer), s_stream);
// Silently tolerate an empty line at the end.
if ((!s || !s[0]) && feof(s_stream))
return nullptr;
String line(s, Chomp);
if (parse_grpdb_entry(line))
return &s_group;
// Otherwise, proceed to the next line.
}
auto& e_name = parts[0];
auto& e_passwd = parts[1];
auto& e_gid_string = parts[2];
auto& e_members_string = parts[3];
auto e_gid = e_gid_string.to_uint();
if (!e_gid.has_value()) {
fprintf(stderr, "getgrent(): Malformed GID on line %u\n", __grdb_line_number);
goto next_entry;
}
auto members = e_members_string.split(',');
__grdb_entry->gr_gid = e_gid.value();
__grdb_entry->gr_name = __grdb_entry->name_buffer;
__grdb_entry->gr_passwd = __grdb_entry->passwd_buffer;
for (size_t i = 0; i < members.size(); ++i) {
__grdb_entry->members[i] = __grdb_entry->members_buffer[i];
strlcpy(__grdb_entry->members_buffer[i], members[i].characters(), sizeof(__grdb_entry->members_buffer[i]));
}
__grdb_entry->members[members.size()] = nullptr;
__grdb_entry->gr_mem = __grdb_entry->members;
strlcpy(__grdb_entry->name_buffer, e_name.characters(), GRDB_STR_MAX_LEN);
strlcpy(__grdb_entry->passwd_buffer, e_passwd.characters(), GRDB_STR_MAX_LEN);
return __grdb_entry;
}
int initgroups(const char* user, gid_t extra_gid)