user.c File Reference

#include "user.h"
#include <curl/curl.h>
#include <jansson.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Data Structures
struct	Buffer
	Buffer structure to hold incoming HTTP response data. More...

Functions
void	buffer_init (Buffer *buf)
	Initialize a Buffer structure.
void	buffer_cleanup (Buffer *buf)
	Free the memory held by a Buffer.
int	buffer_ensure_capacity (Buffer *buf, size_t required_size)
	Ensure that a Buffer has enough capacity for new data.
static size_t	write_callback (const void *contents, size_t size, size_t nmemb, void *userp)
	Callback for libcurl to write response data into a Buffer.
User	fetch_github_user (const char *username)
	Fetch a GitHub user's information via the GitHub API.
void	print_github_user (const User *user)
	Print a User's information to the console.

Function Documentation

buffer_cleanup()

void buffer_cleanup

(

Buffer *

buf

)

Free the memory held by a Buffer.

Parameters

buf	Pointer to Buffer to clean up.

Definition at line 36 of file user.c.

                                 {
  if (buf && buf->data) {
    free(buf->data);
    buf->data = NULL;
    buf->size = 0;
    buf->capacity = 0;
  }
}

References Buffer::capacity, Buffer::data, free, NULL, and Buffer::size.

Referenced by fetch_github_user().

buffer_ensure_capacity()

int buffer_ensure_capacity	(	Buffer *	buf,
		size_t	required_size )

Ensure that a Buffer has enough capacity for new data.

Parameters

buf	Pointer to Buffer.
required_size	Size needed.

Returns

1 if successful, 0 on failure.

Definition at line 52 of file user.c.

                                                              {
  if (buf->capacity >= required_size) {
    return 1; // Enough space
  }
 
  // Double the capacity to ensure enough room
  size_t new_capacity = buf->capacity * 2;
  while (new_capacity < required_size) {
    new_capacity *= 2;
 
    // Protect against integer overflow
    if (new_capacity < buf->capacity) {
      (void)fprintf(stderr, "Buffer capacity overflow\n");
      return 0;
    }
  }
 
  char *new_data = realloc(buf->data, new_capacity);
  if (!new_data) {
    (void)fprintf(stderr, "Memory allocation failed for buffer\n");
    return 0;
  }
 
  buf->data = new_data;
  buf->capacity = new_capacity;
  return 1;
}

References Buffer::capacity, Buffer::data, and realloc.

Referenced by write_callback().

buffer_init()

void buffer_init

(

Buffer *

buf

)

Initialize a Buffer structure.

Parameters

buf	Pointer to Buffer to initialize.

Definition at line 22 of file user.c.

                              {
  buf->data = malloc(1024); // Initial allocation
  buf->size = 0;
  buf->capacity = 1024;
  if (!buf->data) {
    (void)fprintf(stderr, "Memory allocation failed\n");
  }
}

References Buffer::capacity, Buffer::data, malloc, and Buffer::size.

Referenced by fetch_github_user().

fetch_github_user()

User fetch_github_user

(

const char *

username

)

Fetch a GitHub user's information via the GitHub API.

Fetch GitHub user information for a given username.

Parameters

username

GitHub username.

Returns

User structure containing fetched information.

The returned User must be freed using user_free().

Definition at line 130 of file user.c.

                                             {
  User user = {0};
  Buffer buffer = {0};
 
  // Check username for NULL or empty
  if (!username || *username == '\0') {
    (void)fprintf(stderr, "Invalid username\n");
    return user;
  }
 
  buffer_init(&buffer); // Initialize buffer after username check to avoid leaks
 
  // Dynamically allocate URL buffer with enough space for the URL
  size_t username_len = strnlen(username, 100); // Limit username length
  size_t url_size =
      username_len + 50; // Account for the API URL length and username
 
  char *url = malloc(url_size);
  if (!url) {
    (void)fprintf(stderr, "Memory allocation failed for URL\n");
    buffer_cleanup(&buffer);
    return user;
  }
 
  int ret =
      snprintf(url, url_size, "https://api.github.com/users/%s", username);
  if (ret < 0 || (size_t)ret >= url_size) {
    (void)fprintf(stderr, "Error: URL was truncated or snprintf failed\n");
    free(url);
    buffer_cleanup(&buffer);
    return user;
  }
 
  CURL *curl = curl_easy_init();
  if (!curl) {
    (void)fprintf(stderr, "curl init failed\n");
    free(url);
    buffer_cleanup(&buffer);
    return user;
  }
 
  curl_easy_setopt(curl, CURLOPT_URL, url);
  curl_easy_setopt(curl, CURLOPT_USERAGENT, "github_user_fetcher/1.0");
  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
 
  CURLcode res = curl_easy_perform(curl);
  curl_easy_cleanup(curl);
 
  free(url); // Free dynamically allocated URL buffer
 
  if (res != CURLE_OK) {
    (void)fprintf(stderr, "CURL error: %s\n", curl_easy_strerror(res));
    buffer_cleanup(&buffer);
    return user;
  }
 
  json_error_t error;
  json_t *root = json_loads(buffer.data, 0, &error);
 
  // Save buffer data before cleanup
  char *buffer_data = buffer.data;
 
  if (!root) {
    (void)fprintf(stderr, "JSON parse error: %s\n", error.text);
    free(buffer_data);
    return user;
  }
 
  free(buffer_data); // Free buffer data after successful JSON parsing
 
  json_t *login = json_object_get(root, "login");
  json_t *name = json_object_get(root, "name");
  json_t *company = json_object_get(root, "company");
  json_t *location = json_object_get(root, "location");
 
  // Dynamically allocate memory for the user fields
  if (json_is_string(login)) {
    user.login = strdup(
        json_string_value(login)); // Using strdup for dynamic memory allocation
  }
  if (json_is_string(name)) {
    user.name = strdup(json_string_value(name));
  }
  if (json_is_string(company)) {
    user.company = strdup(json_string_value(company));
  }
  if (json_is_string(location)) {
    user.location = strdup(json_string_value(location));
  }
 
  json_decref(root);
  return user;
}

References buffer_cleanup(), buffer_init(), User::company, curl_easy_cleanup(), curl_easy_init(), curl_easy_perform(), curl_easy_setopt, curl_easy_strerror(), CURLE_OK, Buffer::data, error(), free, json_decref(), json_is_string, json_loads(), json_object_get(), json_string_value(), User::location, User::login, malloc, User::name, name, snprintf, and write_callback().

Referenced by main(), Test(), and user_handler().

print_github_user()

void print_github_user

(

const User *

user

)

Print a User's information to the console.

Print GitHub user information to standard output.

Parameters

user	Pointer to the User structure.

Definition at line 230 of file user.c.

                                         {
  if (!user) {
    (void)fprintf(stderr, "NULL user pointer\n");
    return;
  }
 
  printf("GitHub User:\n");
  printf("  Login:    %s\n", user->login ? user->login : "N/A");
  printf("  Name:     %s\n", user->name ? user->name : "N/A");
  printf("  Company:  %s\n", user->company ? user->company : "N/A");
  printf("  Location: %s\n", user->location ? user->location : "N/A");
}

References User::company, User::location, User::login, User::name, and printf.

Referenced by BM_PrintUser(), and main().

write_callback()

static size_t write_callback ( const void * contents, size_t size, size_t nmemb, void * userp )

static

Callback for libcurl to write response data into a Buffer.

Parameters

contents	Pointer to incoming data.
size	Size of a single item.
nmemb	Number of items.
userp	Pointer to Buffer structure.

Returns

Number of bytes handled.

Definition at line 89 of file user.c.

                                          {
  size_t total_size = size * nmemb;
  Buffer *buf = (Buffer *)userp;
 
  // Check for size_t overflow
  if (total_size / size != nmemb) {
    (void)fprintf(stderr, "Integer overflow in size calculation\n");
    return 0;
  }
 
  // Check for overflow when adding to buffer size
  if (total_size > SIZE_MAX - buf->size - 1) {
    (void)fprintf(stderr, "Buffer size would overflow\n");
    return 0;
  }
 
  // Ensure there's enough space for the new data
  if (!buffer_ensure_capacity(buf, buf->size + total_size + 1)) {
    return 0;
  }
 
  // Now we can safely copy the data
  if (total_size > 0) {
    memmove(buf->data + buf->size, contents,
            total_size); // Using memmove instead of memcpy
  }
  buf->size += total_size;
  buf->data[buf->size] = '\0'; // Null-terminate
 
  return total_size;
}

References buffer_ensure_capacity(), Buffer::data, Buffer::size, and SIZE_MAX.

Referenced by fetch_github_user().