327 lines
9.3 KiB
C
327 lines
9.3 KiB
C
/*
|
|
* zzcat - various cat reimplementations for testing purposes
|
|
* Copyright (c) 2006-2009 Sam Hocevar <sam@hocevar.net>
|
|
* All Rights Reserved
|
|
*
|
|
* $Id$
|
|
*
|
|
* This program is free software. It comes without any warranty, to
|
|
* the extent permitted by applicable law. You can redistribute it
|
|
* and/or modify it under the terms of the Do What The Fuck You Want
|
|
* To Public License, Version 2, as published by Sam Hocevar. See
|
|
* http://sam.zoy.org/wtfpl/COPYING for more details.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
/* Needed for lseek64() */
|
|
#define _LARGEFILE64_SOURCE
|
|
/* Needed for O_RDONLY on HP-UX */
|
|
#define _INCLUDE_POSIX_SOURCE
|
|
|
|
#if defined HAVE_STDINT_H
|
|
# include <stdint.h>
|
|
#elif defined HAVE_INTTYPES_H
|
|
# include <inttypes.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#if defined HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#if defined HAVE_SYS_MMAN_H
|
|
# include <sys/mman.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
static int zzcat_read(char const *, unsigned char *, int64_t);
|
|
static int zzcat_fread(char const *, unsigned char *, int64_t);
|
|
static int zzcat_getc(char const *, unsigned char *, int64_t, int);
|
|
#if defined HAVE_GETLINE
|
|
static int zzcat_getdelim_getc(char const *, unsigned char *, int64_t, int);
|
|
#endif
|
|
static int zzcat_fseek_getc(char const *, unsigned char *, int64_t, int);
|
|
static int zzcat_fread_getc(char const *, unsigned char *, int64_t, int);
|
|
static int zzcat_random_socket(char const *, unsigned char *, int64_t);
|
|
static int zzcat_random_stream(char const *, unsigned char *, int64_t);
|
|
#if defined HAVE_MMAP
|
|
static int zzcat_random_mmap(char const *, unsigned char *, int64_t);
|
|
#endif
|
|
|
|
static inline unsigned int myrand(void)
|
|
{
|
|
static int seed = 1;
|
|
int x, y;
|
|
x = (seed + 0x12345678) << 11;
|
|
y = (seed + 0xfedcba98) >> 21;
|
|
seed = x * 1010101 + y * 343434;
|
|
return seed;
|
|
}
|
|
|
|
static inline int mygetc(FILE *stream, int getc_method)
|
|
{
|
|
switch (getc_method)
|
|
{
|
|
#if defined HAVE_GETC_UNLOCKED
|
|
case 3: return fgetc_unlocked(stream);
|
|
case 2: return getc_unlocked(stream);
|
|
#endif
|
|
case 1: return fgetc(stream);
|
|
default: return getc(stream);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int64_t len;
|
|
unsigned char *data;
|
|
char const *name;
|
|
int ret, cmd, fd;
|
|
|
|
if(argc != 3)
|
|
return EXIT_FAILURE;
|
|
|
|
name = argv[2];
|
|
|
|
/* Read the whole file */
|
|
fd = open(name, O_RDONLY);
|
|
if(fd < 0)
|
|
return EXIT_FAILURE;
|
|
len = lseek(fd, 0, SEEK_END);
|
|
if(len < 0)
|
|
return EXIT_FAILURE;
|
|
data = malloc(len + 16); /* 16 safety bytes */
|
|
lseek(fd, 0, SEEK_SET);
|
|
read(fd, data, len);
|
|
close(fd);
|
|
|
|
/* Read shit here and there, using different methods */
|
|
switch((cmd = atoi(argv[1])))
|
|
{
|
|
/* Simple socket calls */
|
|
case 100: ret = zzcat_read(name, data, len); break;
|
|
/* Simple stream calls */
|
|
case 200: ret = zzcat_fread(name, data, len); break;
|
|
case 201: ret = zzcat_getc(name, data, len, 0); break;
|
|
case 202: ret = zzcat_getc(name, data, len, 1); break;
|
|
case 203: ret = zzcat_fseek_getc(name, data, len, 0); break;
|
|
case 204: ret = zzcat_fseek_getc(name, data, len, 1); break;
|
|
case 205: ret = zzcat_fread_getc(name, data, len, 0); break;
|
|
case 206: ret = zzcat_fread_getc(name, data, len, 1); break;
|
|
#if defined HAVE_GETLINE
|
|
case 207: ret = zzcat_getdelim_getc(name, data, len, 0); break;
|
|
case 208: ret = zzcat_getdelim_getc(name, data, len, 1); break;
|
|
#endif
|
|
/* Simple unlocked stream calls */
|
|
#if defined HAVE_GETC_UNLOCKED
|
|
case 300: ret = zzcat_getc(name, data, len, 2); break;
|
|
case 301: ret = zzcat_getc(name, data, len, 3); break;
|
|
case 302: ret = zzcat_fseek_getc(name, data, len, 2); break;
|
|
case 303: ret = zzcat_fseek_getc(name, data, len, 3); break;
|
|
case 304: ret = zzcat_fread_getc(name, data, len, 2); break;
|
|
case 305: ret = zzcat_fread_getc(name, data, len, 3); break;
|
|
# if defined HAVE_GETLINE
|
|
case 306: ret = zzcat_getdelim_getc(name, data, len, 2); break;
|
|
case 307: ret = zzcat_getdelim_getc(name, data, len, 3); break;
|
|
# endif
|
|
#endif
|
|
/* Complex socket calls */
|
|
case 400: ret = zzcat_random_socket(name, data, len); break;
|
|
/* Complex stream calls */
|
|
case 500: ret = zzcat_random_stream(name, data, len); break;
|
|
/* Misc */
|
|
#if defined HAVE_MMAP
|
|
case 600: ret = zzcat_random_mmap(name, data, len); break;
|
|
#endif
|
|
default: ret = EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Write what we have read */
|
|
fwrite(data, len, 1, stdout);
|
|
free(data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* Only read(1) calls */
|
|
static int zzcat_read(char const *name, unsigned char *data, int64_t len)
|
|
{
|
|
int i, fd = open(name, O_RDONLY);
|
|
if(fd < 0)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < len; i++)
|
|
read(fd, data + i, 1);
|
|
close(fd);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Only fread() calls */
|
|
static int zzcat_fread(char const *name, unsigned char *data, int64_t len)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < len; i++)
|
|
fread(data + i, 1, 1, stream);
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Only getc() or fgetc() calls */
|
|
static int zzcat_getc(char const *name, unsigned char *data, int64_t len,
|
|
int getc_method)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < len; i++)
|
|
data[i] = mygetc(stream, getc_method);
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
#if defined HAVE_GETLINE
|
|
/* getdelim() and getc() calls */
|
|
static int zzcat_getdelim_getc(char const *name, unsigned char *data,
|
|
int64_t len, int getc_method)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i = 0, j;
|
|
char c;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
(void)len;
|
|
while ((c = mygetc(stream, getc_method)) != EOF)
|
|
{
|
|
char *line;
|
|
ssize_t ret;
|
|
size_t n;
|
|
|
|
ungetc(c, stream);
|
|
line = NULL;
|
|
ret = getline(&line, &n, stream);
|
|
for (j = 0; j < ret; i++, j++)
|
|
data[i] = line[j];
|
|
}
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
/* One fseek(), then only getc() or fgetc() calls */
|
|
static int zzcat_fseek_getc(char const *name, unsigned char *data,
|
|
int64_t len, int getc_method)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
fseek(stream, len / 2, SEEK_CUR);
|
|
for(i = len / 2; i < len; i++)
|
|
data[i] = mygetc(stream, getc_method);
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* One fread(), then only getc() or fgetc() calls */
|
|
static int zzcat_fread_getc(char const *name, unsigned char *data,
|
|
int64_t len, int getc_method)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
fread(data, 1, len / 2, stream);
|
|
for(i = len / 2; i < len; i++)
|
|
data[i] = mygetc(stream, getc_method);
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Socket seeks and reads */
|
|
static int zzcat_random_socket(char const *name, unsigned char *data,
|
|
int64_t len)
|
|
{
|
|
int i, j, fd = open(name, O_RDONLY);
|
|
if(fd < 0)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < 128; i++)
|
|
{
|
|
lseek(fd, myrand() % len, SEEK_SET);
|
|
for(j = 0; j < 4; j++)
|
|
read(fd, data + lseek(fd, 0, SEEK_CUR), myrand() % 4096);
|
|
#ifdef HAVE_LSEEK64
|
|
lseek64(fd, myrand() % len, SEEK_SET);
|
|
for(j = 0; j < 4; j++)
|
|
read(fd, data + lseek(fd, 0, SEEK_CUR), myrand() % 4096);
|
|
#endif
|
|
}
|
|
close(fd);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/* Standard stream seeks and reads */
|
|
static int zzcat_random_stream(char const *name, unsigned char *data,
|
|
int64_t len)
|
|
{
|
|
FILE *stream = fopen(name, "r");
|
|
int i, j;
|
|
if(!stream)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < 128; i++)
|
|
{
|
|
long int now;
|
|
fseek(stream, myrand() % len, SEEK_SET);
|
|
for(j = 0; j < 4; j++)
|
|
fread(data + ftell(stream),
|
|
myrand() % (len - ftell(stream)), 1, stream);
|
|
fseek(stream, myrand() % len, SEEK_SET);
|
|
now = ftell(stream);
|
|
for(j = 0; j < 16; j++)
|
|
data[now + j] = getc(stream);
|
|
now = ftell(stream);
|
|
for(j = 0; j < 16; j++)
|
|
data[now + j] = fgetc(stream);
|
|
}
|
|
fclose(stream);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
#ifdef HAVE_MMAP
|
|
/* mmap() followed by random memory reads */
|
|
static int zzcat_random_mmap(char const *name, unsigned char *data,
|
|
int64_t len)
|
|
{
|
|
int i, j, fd = open(name, O_RDONLY);
|
|
if(fd < 0)
|
|
return EXIT_FAILURE;
|
|
for(i = 0; i < 128; i++)
|
|
{
|
|
char *map;
|
|
int moff, mlen, pgsz = len + 1;
|
|
#ifdef HAVE_GETPAGESIZE
|
|
pgsz = getpagesize();
|
|
#endif
|
|
moff = len < pgsz ? 0 : (myrand() % (len / pgsz)) * pgsz;
|
|
mlen = 1 + (myrand() % (len - moff));
|
|
map = mmap(NULL, mlen, PROT_READ, MAP_PRIVATE, fd, moff);
|
|
if(map == MAP_FAILED)
|
|
return EXIT_FAILURE;
|
|
for(j = 0; j < 128; j++)
|
|
{
|
|
int x = myrand() % mlen;
|
|
data[moff + x] = map[x];
|
|
}
|
|
munmap(map, mlen);
|
|
}
|
|
close(fd);
|
|
return EXIT_SUCCESS;
|
|
}
|
|
#endif
|
|
|