Accidently creating gigantic file with write - c

Question

this is the code I am using:
#include <stdio.h>
#include <stdlib.h>
void main(){
test = creat("TEST",0751);
close(test);
test = open("TEST",2);
write(test, "123456789101112131415",21);
lseek(test,-2,2);
read(test,swap_array,2);
write(test,swap_array,2);
lseek(test,-6, 1);
write(test,"xx",2);
}
This creates an 8gb file containing instead of inserting "xx" in between the numbers as I intend. What is wrong with the code as I have it?

Answer 1

You have failed to include the appropriate header files. You should include, at a minimum:
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
Additionally, this will give you access to the symbolic constants required to make your code maintainable.
Here is a working version of your program:
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main() {
char swap_array[2];
int test = creat("TEST",0751);
close(test);
test = open("TEST",O_RDWR);
write(test, "123456789101112131415",21);
lseek(test,-2,SEEK_END);
read(test,swap_array,2);
write(test,swap_array,2);
lseek(test,-6, SEEK_CUR);
write(test,"xx",2);
return 0;
}

Answer 2

You probably aren't including the headers, so there's probably no prototype for lseek() in scope, so the 2 in the middle argument is an int, but lseek() expects (a long) an off_t, and you're on a 64-bit machine where sizeof(int) != sizeof(long) so the two 2's are misinterpreted by the system call (maybe treating them as the offset and for whatever reason what's left on the stack is interpreted as SEEK_SET or otherwise jumps to a large offset).
Basically, you're probably passing inaccurately typed information to the system call because you haven't included the correct headers. Classically (before POSIX interfered), the middle 2 would be 2L because the l in lseek() stood for 'long' — prior to that, there was a seek() which took a plain int (in the days of 16-bit int types) — to ensure that a long is passed as lseek()
requires. These days, lseek() requires an off_t; using the prototype is crucial to ensure that what you write is interpreted correctly as an off_t.
There's a lot of UB lurking in that description, but the fact that you're not using SEEK_SET etc raises warning flags. Also, why is the file executable? That doesn't look like executable code you're writing.
This variant of the code is more careful (and doesn't create an 8 GiB file on Mac OS X 10.11.6 with GCC 6.2.0).
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#define MODE_0751 (S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH)
int main(void)
{
// All error checking omitted
char swap_array[2];
int test = creat("TEST", MODE_0751);
close(test);
test = open("TEST", O_RDWR);
write(test, "123456789101112131415", 21);
lseek(test, -2L, SEEK_END);
read(test, swap_array, 2);
write(test, swap_array, 2);
lseek(test, -6L, SEEK_CUR);
write(test, "xx", 2);
close(test);
return 0;
}
I use the L's out of (very) old habit, but they're optional. The various 2's could be replaced by sizeof(swap_array) (and sizeof("xx")-1). I learned C long enough ago that the octal permissions were the only way of doing business; the S_IRWXU and related names were years in the future. I find a 4-digit or 5-digit octal number more readable than a string of S_Iwxyz names.
Make sure you compile your code with options set so that prototypes are required before you can use functions. For example, I use:
$ gcc -O3 -g -std=c11 -Wall -Wextra -Werror -Wmissing-prototypes \
> -Wstrict-prototypes -Wold-style-definition mx19.c -o mx19
$