c program crashes when retrieving sizeof(buff) - c

Question

I am creating a program in C that splits a large text file into 10 segments, and then creates 10 threads with each thread generating a word count for each segment. I took the function word_count from this code: https://github.com/prateek-khatri/seaOfC/blob/master/frequencyMultiThread.c. That program works fine for me, but when I tried to use word_count in my own program, it crashes when trying to get the size of the buffer.
It seems like everything is ok in the function getCurrentSegmentWordcount, but when that function calls word_count, it crashes (segmentation fault) at the line printf("sizeof Buff: %d", sizeof(buff));.
#define _GNU_SOURCE
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>
#define NUMBER_OF_THREADS 10
//struct taken from reference:
struct return_val{
char wordlist[100][100]; //[chars][lines]
int count[100];
} *arr; //array of words
void *print_hello_world(void * tid)
{
//This function prints the thread’s identifier and then exits.
printf("Hello World. Greetings from thread %d\n", tid);
pthread_exit(NULL);
}
void *word_count(void* num)
{
int *ln = num;
unsigned int line_number = *ln;
//line_number++;
printf("Thread %d\n",line_number);
char cmd_p1[9] = "sed -n '\0";
char cmd_p2[2];
sprintf(cmd_p2,"%d",line_number); //stores string in buffer
char cmd_p3[21] = "p' 'maintainers.txt'\0";
char command[100];
command[0] = '\0';
//char * strcat ( char * destination, const char * source );
//appends a copy of source to destination
strcat(command,cmd_p1);
strcat(command,cmd_p2);
strcat(command,cmd_p3);
usleep(line_number);
char cmd[100] = " | tr [:space:] '\\n' | grep -v '^\\s*$' | sort | uniq -c | sort\0";
strcat(command,cmd);
printf("Command: %s\n",command);
//fflush(stdout);
FILE *in;
in= popen(command, "r"); //read command and pipe into the shell
rewind(in); //set file position to beginning of 'in'
char buff[50];
int counter = 0;
//char * fgets ( char * str, int num, FILE * stream );
//reads chars from stream and stores them as string into buff until all of buffer has been read
printf("before\n");
bool testBool = fgets(buff,sizeof(buff),in);
printf("testBool: %d\n", testBool);
//CRASH HAPPENS HERE:
//buff
printf("sizeof Buff: %d", sizeof(buff));
while(fgets(buff,sizeof(buff),in))
{
printf("fire 0.5");
char c=' ';
int i = 0;
int cnt = atoi(buff); //converts string to int.. buff == # of chars in file?
arr[line_number-1].count[counter] = cnt; //at this point line_number == 1
printf("fire1\n");
while(c!='\0')
{
c=buff[i];
buff[i]=buff[i+6];
i++;
}
int cnnt = 0;
while(c!=' ')
{
c = buff[cnnt];
cnnt++;
}
i=0;
while(c!='\0')
{
c=buff[i];
buff[i]=buff[i+cnnt];
i++;
}
sprintf(arr[line_number-1].wordlist[counter],"%s",buff);
printf("%d %s",arr[line_number-1].count[counter],arr[line_number-1].wordlist[counter]);
counter++;
}
printf("final count: %d", counter);
arr[line_number-1].count[counter] = -1;
fclose(in);
//pthread_exit(NULL); //didn't help to move here from getCurrentSegment...()
return NULL;
}
void *getCurrentSegmentWordcount(void * tid) { //declaring file pointer (value?)
int segment = tid;
segment = segment + 1; //converts to int
printf("segment/thread: %d \n", segment);
char text[1000];
//char buffer[150];
FILE *fp = fopen("words.txt", "r");
if(fp == NULL) {
printf("null file");
}
int i = 0;
long lSize;
char *buffer;
if( !fp ) perror("words.txt"),exit(1);
fseek( fp , 0L , SEEK_END);
lSize = ftell( fp );
rewind( fp );
buffer = calloc( 1, lSize+1 );
if( !buffer ) fclose(fp),fputs("memory alloc fails",stderr),exit(1);
if( 1!=fread( buffer , lSize, 1 , fp) )
fclose(fp),free(buffer),fputs("entire read fails",stderr),exit(1);
//printf(buffer);
char *token = strtok(buffer, "~");
if(segment == 1) {
printf("segment 1: %s", token);
word_count(&segment);
}
if(segment == 2) {
token = strtok(NULL,"~");
printf("segment 2: %s", token);
}
if(segment == 3) {
token = strtok(NULL,"~");
token = strtok(NULL,"~");
printf("segment 3: %s", token);
}
if(segment == 4) {
token = strtok(NULL,"~");
token = strtok(NULL,"~");
token = strtok(NULL,"~");
printf("segment 4: %s", token);
}
fclose(fp);
free(buffer);
//pthread_exit(NULL);//moving to end of word_count()
}
int main(int argc, char *argv[])
{
//The main program creates x threads and then exits.
pthread_t threads[NUMBER_OF_THREADS];
int status, i;
for(i=0; i < NUMBER_OF_THREADS; i++) {
printf("Main here. Creating thread %d\n", i+1);
status = pthread_create(&threads[i], NULL, getCurrentSegmentWordcount, (void * )i);
if (status != 0) {
printf("Oops. pthread create returned error code %d\n", status);
exit(-1);
}
}
sleep(8);
exit(NULL);
}
Output:
Main here. Creating thread 1
Main here. Creating thread 2
segment/thread: 1
Main here. Creating thread 3
segment 1: test(segment 1, handled my thread 1)
Thread 1
Main here. Creating thread 4
Command: sed -n '1p' 'maintainers.txt' | tr [:space:] '\n' | grep -v '^\s*$' | sort | uniq -c | sort
Main here. Creating thread 5
segment/thread: 2
before
segment/thread: 4
Main here. Creating thread 6
segment 4:
test test test test (segment 4, handled by thread 4)
Main here. Creating thread 7
segment 2:
test test (segment 2, handled by thread 2)
Main here. Creating thread 8
Main here. Creating thread 9
Main here. Creating thread 10
segment/thread: 3
segment 3:
test test test (segment 3, handled by thread 3)
segment/thread: 10
segment/thread: 9
segment/thread: 8
segment/thread: 5
segment/thread: 6
segment/thread: 7
testBool: 1
Makefile:20: recipe for target 'all' failed
make: *** [all] Segmentation fault (core dumped)

Answer 1

There are many issues with this code, some have been already mentioned by
user3629249, so I'll try to summarize the errors here.
Passing (void * )i for the argument for the thread is rather ugly. Sure it
works but this is for me sloppy programming, I'd declare an int array and fill
it with the id values and pass a pointer to the locations.
int ids[NUMBER_OF_THREADS];
for(i=0; i < NUMBER_OF_THREADS; i++) {
ids[i] = i+1;
status = pthread_create(&threads[i], NULL, getCurrentSegmentWordcount, ids + i);
...
}
and then in the thread function:
void *getCurrentSegmentWordcount(void * tid) { //declaring file pointer (value?)
int segment = *((int*) tid);
// segment = segment + 1; not needed anymore
...
}
This code is more clean, easier to understand for you and for the code reviewer,
does not relay on ugly unnecessary casts and is more portable.
Same thing with
void *print_hello_world(void *tid)
{
//This function prints the thread’s identifier and then exits.
printf("Hello World. Greetings from thread %d\n", tid);
pthread_exit(NULL);
}
This is uggly, you are trying to pass a pointer as an int. The size of a
pointer may not be the same as the size of an int. Using the same way of
passing a pointer to int (like for getCurrentSegmentWordcount):
void *print_hello_world(void *tid)
{
//This function prints the thread’s identifier and then exits.
printf("Hello World. Greetings from thread %d\n", *((int*) tid));
pthread_exit(NULL);
}
Write error messages to stderr. This FILE buffer is opened for that reason,
that's what people expect from programs to do. When you execute a program, you
can do this:
$ program 2>/tmp/error.log
or this
$ program 2>/dev/null | some_other_tool
so that you can separate the normal output from the error outputs.
And when a system function fails, the errno variable is set to the error code.
You can use perror for a standard error message or if you want a custom one,
use strerror:
pid_t p = fork();
if(p < 0)
{
perror("fork failed");
// or
fprintf(stderr, "Error while executing fork: %s\n", strerror(errno));
return; // or exit or whatever
}
You can write code in one line if you want to enter the C obfuscated contest,
otherwise don't do that. It's hard to read for you, it's hard to read for the
code reviewer/co-worker/superior. You gain nothing from it.
Instead of
if( !buffer ) fclose(fp),fputs("memory alloc fails",stderr),exit(1);
do
if(buffer == NULL)
{
fclose(fp);
fputs("memory alloc fails", stderr);
exit(EXIT_FAILURE); // or exit(your_exit_status)
}
It's easier to read for everyone.
You should always check the return value of functions that return a pointer.
Check the return value of malloc, calloc, realloc, strtok, etc.
if(segment == 2) {
token = strtok(NULL,"~");
printf("segment 2: %s", token);
}
If strtok returns NULL, then the printf line yields undefined behaviour.
See 3.5.3.3 comment 2:
3.5.3.3:
Synopsis
#define __STDC_WANT_LIB_EXT1__ 1
#include <stdio.h>
int printf_s(const char * restrict format, ...);
[...]
2 format shall not be a null pointer. The %n specifier (modified or not by flags, field width, or precision) shall not appear in the string pointed to by format. Any argument to printf_s corresponding to a %s specifier shall not be a null pointer.
[...]
4 The printf_s function is equivalent to the printf function except for the explicit runtime-constraints listed above.
Some libc implementation may forgive you to pass NULL to printf with %s
and print (null), but this is not portable and is undefined behaviour. So you
can only do the printf if token is not NULL.
The word_count function is a little bit horrible, specially how you construct
the commands.
char cmd_p1[9] = "sed -n '\0";
can be rewritten as
char cmd_p1[] = "sed -n '";
This will create a char array with the correct amount of bytes and initialize
it with a valid 0-terminated string, no need to add the '\0' yourself.
The commands that are the same, meaning that they don't need a value from a
variable can be store in a char[] or even in a const char*. Then construct
the whole thing with snprintf and sprintf, less lines, less mistakes:
void *word_count(void* num)
{
...
const char *pipe_cmd = "| tr [:space:] '\\n' | grep -v '^\\s*$' | sort | uniq -c | sort";
const char *format = "sed -n '%dp' 'maintainers.txt' %s";
int cmd_size = snprintf(NULL, 0, format, line_number, pipe_cmd);
char *command = malloc(cmd_size + 1);
if(command == NULL)
return NULL;
sprintf(command, format, line_number, pipe_cmd);
...
FILE *in;
in= popen(command, "r");
free(command);
...
}
Also note that
char cmd_p2[2];
sprintf(cmd_p2,"%d",line_number); //stores string in buffer
will overflow the buffer if the line number is greater than 9.
bool testBool = fgets(buff,sizeof(buff),in);
printf("testBool: %d\n", testBool);
fgets returns a pointer to char, not a bool. The printf will print the
value of a pointer as an integer. A pointer size is not necessarily the same as
an int size, in fact on my system a pointer is 8 bytes long, int is 4 bytes
long. You should do:
if(fgets(buff, sizeof(buff), in))
puts("fgets success");
//CRASH HAPPENS HERE:
//buff
printf("sizeof Buff: %d", sizeof(buff));
It won't crash because of the sizeof. sizeof is evaluated at compile time,
not at run-time.
The sizeof-operator returns a size_t.
%d is not the correct specifier for size_t, %lu is, it should be
printf("sizeof buff: %lu\n", sizeof buff);
It will most probably crash because of all the undefined behaviour before
this point.
arr[line_number-1].count[counter] = cnt;
In your whole code, arr is uninitialized, so you are accessing a value
through an uninitialized pointer. That's undefined behaviour and might lead to a
segfault.
I want to quote user3629249 here:
user3629249 wrote:
the main() function is starting several threads, then immediately exiting. The process of exiting also eliminates the threads Suggest: in main() calling pthread_join() for each thread. in the thread, at the end, call pthread_exit()
Please don't ignore compiler warnings, they are not there to annoy you, they are
there to help you. They are a hint that what you are doing may not be what you
really want. Undefined behaviour, segfaults etc. are often a consequence of
that. So heed warnings of the compiler and when you see one, look at your code,
try to understand it and fix it. If you don't understand the warning, you can
come here and ask a question about it. But having thousand of warning and
ignoring them will lead to headaches and quite franky a lot of wasted time on
your side and ours.
So, please fix all this warnings and details, look at the warning messages of
the compiler and the code might run without problems.