GCC based SIGSEGV error?

Question

So I have been writing a handful of C libraries for my own personal use and I have been doing swell until my latest library, which just contains a bunch of string functions. As you can probably tell by the question title, I am getting a SIGSEGV signal. The problem is this: my research indicates that about 99% of all SIGSEGV errors are due to stack overflow, itself due to bad recursion, but as you will see, I am not using any recursion. Furthermore, there are a few odd problems that occur. For one, printf is exhibiting a lot of funky behavior. GDB encounters printf calls but does not actually seem to execute them until a few lines of code later. Likewise, one of my printf statements is being broken up somehow, and only a part is being called, with another part being chopped off apparently.

Here are the key code snippets, some stuff is named funny because I suspected name clashing may be the cause at one point and may have gone a little overboard...

"firstIndexOf" function (finds the first index of a character in a string, if that character is in said string), found at line 31:

int firstIndexOfFUNCTION(char thisChar, char* inThisString)
 {
        int lengthABC = strlen(inThisString);
        printf("\nLength of %s is %d",inThisString,lengthABC);
        int thisFunctionsIndex;
        for (thisFunctionsIndex=0;thisFunctionsIndex<lengthABC;thisFunctionsIndex++)
        {
                printf("\n%dth iteration:\n-char 1 is %c\n-char2 is %c",thisFunctionsIndex,inThisString[thisFunctionsIndex],thisChar);
                if (inThisString[thisFunctionsIndex] == thisChar)
                {
                        printf("\nMatch found on iteration %d!",thisFunctionsIndex);
                        return thisFunctionsIndex;
                }
        }
        printf("\nNo matches detected...");
        return -3;
 }

The "string_functions_test" function (a function just meant to test the other functions) at line 62:

int string_functions_test()
{
        printf("PROGRAM INITIALIZED!\n\n");
        char* sft_string;
        int sft_index;

        sft_string = malloc(sizeof(char)*100);
        sft_string = "B um sbm. Sbm B bm.";

        printf("2nd BREAKPOINT");

        sft_index = firstIndexOfFUNCTION('B',sft_string);

        sft_string[sft_index] = 'I';

        return 0;
}

and last but not least, good ol' main, at line 107:

int main(int argc, char* argv[])
{
        string_functions_test();
        return 0;
}

Here is the gdb output for a step-through of my code:

(gdb) b 105
Breakpoint 1 at 0x400970: file string_functions.c, line 105.
(gdb) run
Starting program: /home/user/Development/projects/c/string_functions/source/c/a.out

Breakpoint 1, main (argc=1, argv=0x7fffffffde98) at string_functions.c:109
109             string_functions_test();
(gdb) step
string_functions_test () at string_functions.c:64
64              printf("PROGRAM INITIALIZED!\n\n");
(gdb) next
PROGRAM INITIALIZED!

68              sft_string = malloc(sizeof(char)*100);
(gdb) next
69              sft_string = "B um sbm. Sbm B bm.";
(gdb) next
71              printf("2nd BREAKPOINT");
(gdb) next
73              sft_index = firstIndexOfFUNCTION('B',sft_string);
(gdb) step
firstIndexOfFUNCTION (thisChar=66 'B', inThisString=0x400ab9 "B um sbm. Sbm B bm.") at string_functions.c:33
33              int lengthABC = strlen(inThisString);
(gdb) next
34              printf("\nLength of %s is %d",inThisString,lengthABC);
(gdb) next
2nd BREAKPOINT
36              for (thisFunctionsIndex=0;thisFunctionsIndex<lengthABC;thisFunctionsIndex++)
(gdb) next
38                      printf("\n%dth iteration:\n-char 1 is %c\n-char2 is %c",thisFunctionsIndex,inThisString[thisFunctionsIndex],thisChar);
(gdb) next
Length of B um sbm. Sbm B bm. is 19
0th iteration:
-char 1 is B
39                      if (inThisString[thisFunctionsIndex] == thisChar)
(gdb) next
41                              printf("\nMatch found on iteration %d!",thisFunctionsIndex);
(gdb) next
-char2 is B
42                              return thisFunctionsIndex;
(gdb) next
47       }
(gdb) next
string_functions_test () at string_functions.c:75
75              sft_string[sft_index] = 'I';
(gdb) next

Program received signal SIGSEGV, Segmentation fault.
0x0000000000400883 in string_functions_test () at string_functions.c:75
75              sft_string[sft_index] = 'I';
(gdb) next

Program terminated with signal SIGSEGV, Segmentation fault.
The program no longer exists.
(gdb) quit

You may notice that the printf which prints "2nd Breakpoint" is called, and then the program steps into a different function before the results are seen. I am assuming this is some whacky behavior on the part of the gcc compiler meant to serve as a cpu optimization, but it is sort of messing me up right now obviously. Likewise, the printf in my for loop is being broken up after the first formatted char. These two things are making it super hard to detect what exactly is happening. Has anyone experienced similar behavior?

In case it matters, I am including:

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

Answer 1

You are first pointing the pointer sft_string to what is returned from malloc. In the next line you make it point to a literal string. You need to copy it. A literal is built into the source code and cannot be changed during execution. Otherwise it raises a segment fault, which means that an area of memory that has code is being changed. Use strcpy.