mika/libnx
1
0
Fork 0
mirror of https://github.com/switchbrew/libnx.git synced 2025-06-22 21:02:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

resolver: Minor codestyle fixes

Browse Source
This commit is contained in:
fincs 2019-10-28 13:00:07 +01:00
parent 1e0bcfbf87
commit 0378d553e0
No known key found for this signature in database
GPG Key ID: 62C7609ADA219C60
1 changed files with 43 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
nx/source/runtime/resolver.c
View File

@ -99,10 +99,9 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
pos_aliases = pos; pos_aliases = pos;
if(nb_aliases>0) { if (nb_aliases) {
for(nb_pos=0, len = 1; nb_pos<nb_aliases; nb_pos++, pos += len + 1) { for (nb_pos = 0, len = 1; nb_pos < nb_aliases; nb_pos++, pos += len + 1)
len = strlen(pos); len = strlen(pos);
}
} }
total_aliases_size = pos - pos_aliases; total_aliases_size = pos - pos_aliases;
@ -114,7 +113,7 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
pos += 2; pos += 2;
// sfdnsres will only return IPv4 addresses for the "host" commands // sfdnsres will only return IPv4 addresses for the "host" commands
if(addrtype != AF_INET || addrlen != sizeof(struct in_addr)) { if (addrtype != AF_INET || addrlen != sizeof(struct in_addr)) {
*err = NO_ADDRESS; *err = NO_ADDRESS;
return NULL; return NULL;
} }
@ -126,7 +125,7 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
pos_addresses = pos; pos_addresses = pos;
pos += addrlen * nb_addresses; pos += addrlen * nb_addresses;
he = (struct hostent *)malloc( he = malloc(
sizeof(struct hostent) sizeof(struct hostent)
+ name_size + name_size
+ 8 * (nb_aliases + 1 + nb_addresses + 1) + 8 * (nb_aliases + 1 + nb_addresses + 1)
@ -134,7 +133,7 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
+ addrlen * nb_addresses + addrlen * nb_addresses
); );
if(he == NULL) { if (!he) {
*err = NO_RECOVERY; *err = NO_RECOVERY;
return NULL; return NULL;
} }
@ -153,7 +152,7 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
he->h_length = addrlen; he->h_length = addrlen;
he->h_addr_list = he->h_aliases + nb_aliases + 1; he->h_addr_list = he->h_aliases + nb_aliases + 1;
if(nb_aliases>0) { if (nb_aliases) {
char *alias = (char *)(he->h_addr_list + nb_addresses + 1); char *alias = (char *)(he->h_addr_list + nb_addresses + 1);
memcpy(alias, pos_aliases, total_aliases_size); memcpy(alias, pos_aliases, total_aliases_size);
for(size_t i = 0; i < nb_aliases; i++) { for(size_t i = 0; i < nb_aliases; i++) {
@ -163,10 +162,10 @@ static struct hostent *_resolverDeserializeHostent(int *err, const void *out_he_
} }
he->h_aliases[nb_aliases] = NULL; he->h_aliases[nb_aliases] = NULL;
if(nb_addresses>0) { if (nb_addresses) {
struct in_addr *addresses = (struct in_addr *)(he->h_addr_list + nb_addresses + 1 + total_aliases_size); struct in_addr *addresses = (struct in_addr *)(he->h_addr_list + nb_addresses + 1 + total_aliases_size);
memcpy(addresses, pos_addresses, addrlen * nb_addresses); memcpy(addresses, pos_addresses, addrlen * nb_addresses);
for(size_t i = 0; i < nb_addresses; i++) { for (size_t i = 0; i < nb_addresses; i ++) {
he->h_addr_list[i] = (char *)&addresses[i]; he->h_addr_list[i] = (char *)&addresses[i];
addresses[i].s_addr = ntohl(addresses[i].s_addr); // lol Nintendo addresses[i].s_addr = ntohl(addresses[i].s_addr); // lol Nintendo
} }
@ -186,21 +185,21 @@ struct addrinfo_serialized_hdr {
}; };
static size_t _resolverSerializeAddrInfo(struct addrinfo_serialized_hdr *hdr, const struct addrinfo *ai) { static size_t _resolverSerializeAddrInfo(struct addrinfo_serialized_hdr *hdr, const struct addrinfo *ai) {
size_t subsize1 = (ai->ai_addr == NULL || ai->ai_addrlen == 0) ? 4 : ai->ai_addrlen; // not posix-compliant ? size_t subsize1 = (ai->ai_addr && ai->ai_addrlen) ? ai->ai_addrlen : 4; // not posix-compliant ?
size_t subsize2 = ai->ai_canonname == NULL ? 1 : (strlen(ai->ai_canonname) + 1); size_t subsize2 = ai->ai_canonname ? strlen(ai->ai_canonname) + 1 : 1;
hdr->magic = htonl(0xBEEFCAFE); // Seriously. hdr->magic = htonl(0xBEEFCAFE); // Seriously.
hdr->ai_flags = htonl(ai->ai_flags); hdr->ai_flags = htonl(ai->ai_flags);
hdr->ai_family = htonl(ai->ai_family); hdr->ai_family = htonl(ai->ai_family);
hdr->ai_socktype = htonl(ai->ai_socktype); hdr->ai_socktype = htonl(ai->ai_socktype);
hdr->ai_protocol = htonl(ai->ai_protocol); hdr->ai_protocol = htonl(ai->ai_protocol);
hdr->ai_addrlen = ai->ai_addr == NULL ? 0 : htonl((u32)ai->ai_addrlen); hdr->ai_addrlen = ai->ai_addr ? htonl((u32)ai->ai_addrlen) : 0;
if(hdr->ai_addrlen == 0) if (hdr->ai_addrlen == 0)
*(u32 *)((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr)) = 0; *(u32 *)((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr)) = 0;
else { else {
// Nintendo just byteswaps everything recursively... even fields that are already byteswapped. // Nintendo just byteswaps everything recursively... even fields that are already byteswapped.
switch(ai->ai_family) { switch (ai->ai_family) {
case AF_INET: { case AF_INET: {
struct sockaddr_in sa = {0}; struct sockaddr_in sa = {0};
memcpy(&sa, ai->ai_addr, subsize1 <= sizeof(struct sockaddr_in) ? subsize1 : sizeof(struct sockaddr_in)); memcpy(&sa, ai->ai_addr, subsize1 <= sizeof(struct sockaddr_in) ? subsize1 : sizeof(struct sockaddr_in));
@ -223,36 +222,38 @@ static size_t _resolverSerializeAddrInfo(struct addrinfo_serialized_hdr *hdr, co
} }
} }
if(ai->ai_canonname == NULL) if (ai->ai_canonname)
*((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1) = 0;
else
memcpy((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1, ai->ai_canonname, subsize2); memcpy((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1, ai->ai_canonname, subsize2);
else
*((u8 *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1) = 0;
return sizeof(struct addrinfo_serialized_hdr) + subsize1 + subsize2; return sizeof(struct addrinfo_serialized_hdr) + subsize1 + subsize2;
} }
static struct addrinfo_serialized_hdr *_resolverSerializeAddrInfoList(size_t *out_size, const struct addrinfo *ai) { static struct addrinfo_serialized_hdr *_resolverSerializeAddrInfoList(size_t *out_size, const struct addrinfo *ai) {
size_t total_addrlen = 0, total_namelen = 0, n = 0; size_t total_addrlen = 0, total_namelen = 0, n = 0;
struct addrinfo_serialized_hdr *out, *pos; for (const struct addrinfo *node = ai; node; node = node->ai_next) {
total_addrlen += node->ai_addrlen ? node->ai_addrlen : 4;
for(const struct addrinfo *node = ai; node != NULL; node = node->ai_next) { total_namelen += node->ai_canonname ? strlen(node->ai_canonname) + 1 : 1;
total_addrlen += node->ai_addrlen == 0 ? 4 : node->ai_addrlen;
total_namelen += node->ai_canonname == NULL ? 1 : (strlen(node->ai_canonname) + 1);
n++; n++;
} }
out = (struct addrinfo_serialized_hdr *)malloc(sizeof(struct addrinfo_serialized_hdr) * n + total_addrlen + total_namelen + 4); size_t reqsize = sizeof(struct addrinfo_serialized_hdr) * n + total_addrlen + total_namelen + 4;
if(out == NULL) if (reqsize > g_resolverAddrInfoHintsBufferSize)
return NULL; return NULL;
pos = out; struct addrinfo_serialized_hdr *out = malloc(reqsize);
for(const struct addrinfo *node = ai; node != NULL; node = node->ai_next) { if (!out)
return NULL;
struct addrinfo_serialized_hdr *pos = out;
for (const struct addrinfo *node = ai; node; node = node->ai_next) {
size_t len = _resolverSerializeAddrInfo(pos, node); size_t len = _resolverSerializeAddrInfo(pos, node);
pos = (struct addrinfo_serialized_hdr *)((u8 *)pos + len); pos = (struct addrinfo_serialized_hdr *)((u8 *)pos + len);
} }
*(u32 *)pos = 0; // Sentinel value
*out_size = (u8 *)pos - (u8 *)out + 4; *(u32 *)pos = 0; // Sentinel value
*out_size = reqsize;
return out; return out;
} }
@ -263,12 +264,12 @@ static struct addrinfo *_resolverDeserializeAddrInfo(size_t *out_len, const stru
char canonname[]; char canonname[];
}; };
size_t subsize1 = hdr->ai_addrlen == 0 ? 4 : ntohl(hdr->ai_addrlen); size_t subsize1 = hdr->ai_addrlen ? ntohl(hdr->ai_addrlen) : 4;
size_t subsize2 = strlen((const char *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1) + 1; size_t subsize2 = strlen((const char *)hdr + sizeof(struct addrinfo_serialized_hdr) + subsize1) + 1;
struct addrinfo_node *node = (struct addrinfo_node *)malloc(sizeof(struct addrinfo_node) + subsize2); struct addrinfo_node *node = malloc(sizeof(struct addrinfo_node) + subsize2);
*out_len = sizeof(struct addrinfo_serialized_hdr) + subsize1 + subsize2; *out_len = sizeof(struct addrinfo_serialized_hdr) + subsize1 + subsize2;
if(node == NULL) if (!node)
return NULL; return NULL;
node->info.ai_flags = ntohl(hdr->ai_flags); node->info.ai_flags = ntohl(hdr->ai_flags);
@ -278,16 +279,16 @@ static struct addrinfo *_resolverDeserializeAddrInfo(size_t *out_len, const stru
node->info.ai_addrlen = ntohl(hdr->ai_addrlen); node->info.ai_addrlen = ntohl(hdr->ai_addrlen);
// getaddrinfo enforces addrlen = sizeof(struct sockaddr) and family = AF_INET, ie. only IPv4, anyways... // getaddrinfo enforces addrlen = sizeof(struct sockaddr) and family = AF_INET, ie. only IPv4, anyways...
if(node->info.ai_addrlen > sizeof(struct sockaddr_storage)) if (node->info.ai_addrlen > sizeof(struct sockaddr_storage))
node->info.ai_addrlen = sizeof(struct sockaddr_storage); node->info.ai_addrlen = sizeof(struct sockaddr_storage);
if(node->info.ai_addrlen == 0) if (node->info.ai_addrlen == 0)
node->info.ai_addr = NULL; node->info.ai_addr = NULL;
else { else {
node->info.ai_addr = (struct sockaddr *)&node->addr; node->info.ai_addr = (struct sockaddr *)&node->addr;
memcpy(node->info.ai_addr, (const u8 *)hdr + sizeof(struct addrinfo_serialized_hdr), node->info.ai_addrlen); memcpy(node->info.ai_addr, (const u8 *)hdr + sizeof(struct addrinfo_serialized_hdr), node->info.ai_addrlen);
// Nintendo just byteswaps everything recursively... even fields that are already byteswapped. // Nintendo just byteswaps everything recursively... even fields that are already byteswapped.
switch(node->info.ai_family) { switch (node->info.ai_family) {
case AF_INET: { case AF_INET: {
struct sockaddr_in *sa = (struct sockaddr_in *)node->info.ai_addr; struct sockaddr_in *sa = (struct sockaddr_in *)node->info.ai_addr;
sa->sin_len = 6; sa->sin_len = 6;
@ -307,7 +308,7 @@ static struct addrinfo *_resolverDeserializeAddrInfo(size_t *out_len, const stru
} }
} }
if(subsize2 == 1) if (subsize2 == 1)
node->info.ai_canonname = NULL; node->info.ai_canonname = NULL;
else { else {
node->info.ai_canonname = node->canonname; node->info.ai_canonname = node->canonname;
@ -322,19 +323,19 @@ static struct addrinfo *_resolverDeserializeAddrInfo(size_t *out_len, const stru
static struct addrinfo *_resolverDeserializeAddrInfoList(struct addrinfo_serialized_hdr *hdr) { static struct addrinfo *_resolverDeserializeAddrInfoList(struct addrinfo_serialized_hdr *hdr) {
struct addrinfo *first = NULL, *prev = NULL; struct addrinfo *first = NULL, *prev = NULL;
while(hdr->magic == htonl(0xBEEFCAFE)) { while (hdr->magic == htonl(0xBEEFCAFE)) {
size_t len; size_t len;
struct addrinfo *node = _resolverDeserializeAddrInfo(&len, hdr); struct addrinfo *node = _resolverDeserializeAddrInfo(&len, hdr);
if(node == NULL) { if (!node) {
if(first != NULL) if (first)
freeaddrinfo(first); freeaddrinfo(first);
return NULL; return NULL;
} }
if(first == NULL) if (!first)
first = node; first = node;
if(prev != NULL) if (prev)
prev->ai_next = node; prev->ai_next = node;
prev = node; prev = node;
@ -349,8 +350,7 @@ void freehostent(struct hostent *he) {
} }
void freeaddrinfo(struct addrinfo *ai) { void freeaddrinfo(struct addrinfo *ai) {
if(ai == NULL) return; // not specified by POSIX, but that's convenient (FreeBSD does this too, etc.). for (struct addrinfo *node = ai, *next; node; node = next) {
for(struct addrinfo *node = ai, *next; node != NULL; node = next) {
next = node->ai_next; next = node->ai_next;
free(node); free(node);
} }
@ -503,8 +503,6 @@ int getaddrinfo(const char *node, const char *service, const struct addrinfo *hi
size_t hints_sz = 0; size_t hints_sz = 0;
struct addrinfo_serialized_hdr *hints_serialized = NULL; struct addrinfo_serialized_hdr *hints_serialized = NULL;
if (hints) { if (hints) {
// TODO: fixed size for serialized hints (g_resolverAddrInfoHintsBufferSize)
(void)g_resolverAddrInfoHintsBufferSize;
hints_serialized = _resolverSerializeAddrInfoList(&hints_sz, hints); hints_serialized = _resolverSerializeAddrInfoList(&hints_sz, hints);
if (!hints_serialized) { if (!hints_serialized) {
errno = ENOMEM; errno = ENOMEM;
@ -616,7 +614,7 @@ int gethostname(char *name, size_t namelen) {
struct in_addr in; struct in_addr in;
in.s_addr = gethostid(); in.s_addr = gethostid();
const char *hostname = inet_ntop(AF_INET, &in, name, namelen); const char *hostname = inet_ntop(AF_INET, &in, name, namelen);
return hostname == NULL ? -1 : 0; return hostname ? 0 : -1;
} }
// Unimplementable functions, left for compliance: // Unimplementable functions, left for compliance: