zircon/system/utest/fs/test-overflow.c

// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include "filesystems.h"
#include "misc.h"

// Given a buffer of size PATH_MAX, make a 'len' byte long filename (not including null) consisting
// of the character 'c'.
static void make_name(char* buf, size_t len, char c) {
  memset(buf, ':', 2);
  buf += 2;
  memset(buf, c, len);
  buf[len] = '\0';
}

// Extends 'name' with a string 'len' bytes long, of the character 'c'.
// Assumes 'name' is large enough to hold 'len' additional bytes (and a new null character).
static void extend_name(char* name, size_t len, char c) {
  char buf[PATH_MAX];
  assert(len < PATH_MAX);
  memset(buf, c, len);
  buf[len] = '\0';
  strcat(name, "/");
  strcat(name, buf);
}

bool test_overflow_name(void) {
  BEGIN_TEST;

  char name_largest[PATH_MAX];
  char name_largest_alt[PATH_MAX];
  char name_too_large[PATH_MAX];
  make_name(name_largest, NAME_MAX, 'a');
  make_name(name_largest_alt, NAME_MAX, 'b');
  make_name(name_too_large, NAME_MAX + 1, 'a');

  // Try opening, closing, renaming, and unlinking the largest acceptable name
  int fd = open(name_largest, O_RDWR | O_CREAT | O_EXCL, 0644);
  ASSERT_GT(fd, 0, "");
  ASSERT_EQ(close(fd), 0, "");
  ASSERT_EQ(rename(name_largest, name_largest_alt), 0, "");
  ASSERT_EQ(rename(name_largest_alt, name_largest), 0, "");

  ASSERT_EQ(rename(name_largest, name_too_large), -1, "");
  ASSERT_EQ(rename(name_too_large, name_largest), -1, "");
  ASSERT_EQ(unlink(name_largest), 0, "");

  // Try it with a directory too
  ASSERT_EQ(mkdir(name_largest, 0755), 0, "");
  ASSERT_EQ(rename(name_largest, name_largest_alt), 0, "");
  ASSERT_EQ(rename(name_largest_alt, name_largest), 0, "");

  ASSERT_EQ(rename(name_largest, name_too_large), -1, "");
  ASSERT_EQ(rename(name_too_large, name_largest), -1, "");
  ASSERT_EQ(unlink(name_largest), 0, "");

  // Try opening an unacceptably large name
  ASSERT_EQ(open(name_too_large, O_RDWR | O_CREAT | O_EXCL, 0644), -1, "");
  // Try it with a directory too
  ASSERT_EQ(mkdir(name_too_large, 0755), -1, "");

  END_TEST;
}

bool test_overflow_path(void) {
  BEGIN_TEST;

  // Make the name buffer larger than PATH_MAX so we don't overflow
  char name[2 * PATH_MAX];

  int depth = 0;

  // Create an initial directory
  make_name(name, NAME_MAX, 'a');
  ASSERT_EQ(mkdir(name, 0755), 0, "");
  depth++;
  // Create child directories until we hit PATH_MAX
  while (true) {
    extend_name(name, NAME_MAX, 'a');
    int r = mkdir(name, 0755);
    if (r < 0) {
      assert(errno == ENAMETOOLONG);
      break;
    }
    depth++;
  }

  // Remove all child directories
  while (depth != 0) {
    char* last_slash = strrchr(name, '/');
    assert(last_slash != NULL);
    assert(*last_slash == '/');
    *last_slash = '\0';
    ASSERT_EQ(unlink(name), 0, "");
    depth--;
  }

  END_TEST;
}

bool test_overflow_integer(void) {
  BEGIN_TEST;

  int fd = open("::file", O_CREAT | O_RDWR | O_EXCL, 0644);
  ASSERT_GT(fd, 0, "");

  // TODO(smklein): Test extremely large reads/writes when remoteio can handle them without
  // crashing
  /*
  char buf[4096];
  ASSERT_EQ(write(fd, buf, SIZE_MAX - 1), -1, "");
  ASSERT_EQ(write(fd, buf, SIZE_MAX), -1, "");

  ASSERT_EQ(read(fd, buf, SIZE_MAX - 1), -1, "");
  ASSERT_EQ(read(fd, buf, SIZE_MAX), -1, "");
  */

  ASSERT_EQ(ftruncate(fd, INT_MIN), -1, "");
  ASSERT_EQ(ftruncate(fd, -1), -1, "");
  ASSERT_EQ(ftruncate(fd, SIZE_MAX - 1), -1, "");
  ASSERT_EQ(ftruncate(fd, SIZE_MAX), -1, "");

  ASSERT_EQ(lseek(fd, INT_MIN, SEEK_SET), -1, "");
  ASSERT_EQ(lseek(fd, -1, SEEK_SET), -1, "");
  ASSERT_EQ(lseek(fd, SIZE_MAX - 1, SEEK_SET), -1, "");
  ASSERT_EQ(lseek(fd, SIZE_MAX, SEEK_SET), -1, "");
  ASSERT_EQ(close(fd), 0, "");
  ASSERT_EQ(unlink("::file"), 0, "");

  END_TEST;
}

RUN_FOR_ALL_FILESYSTEMS(overflow_tests,
                        RUN_TEST_MEDIUM(test_overflow_name) RUN_TEST_MEDIUM(test_overflow_path)
                            RUN_TEST_MEDIUM(test_overflow_integer))