Can some one explain what BUS error: "invalid address alignment means".  I
am getting a core dump because of this error.

In most cases, however, compilers, knowing the architecture of the
machine you're compiling for, won't let this happen; they assure that
data is aligned correctly.

It is most likely that you have a bug in your code.

Likely causes:
Trying to store data via an uninitialized pointer (or one that has not
had memory allocated to it)
Using _really_ funky casts...

things like that.

Why not post a minimal, compilable snippet of code that displays the
problem? It will make diagnosis much much easier!

HTH,
--ag

        http://www.eskimo.com/~scs/C-faq/top.html

while (mr != NULL) {
  if (mr->pd != NULL) {
    if (keyword_exist("made for TV",mr->kd) == 1){
            if (mr->pd->origin != NULL) {
             free(mr->pd->origin);
           }
           mr->pd->origin = (char *) calloc(40, sizeof(char));
           strcpy(mr->pd->origin,"Made for TV");
    }
    else if (keyword_exist("made for cable",mr->kd) == 1) {
           if (mr->pd->origin != NULL) {
             free(mr->pd->origin);
           }
           mr->pd->origin = (char *) calloc(40, sizeof(char));
           strcpy(mr->pd->origin,"Made for Cable");
    }
    else if (keyword_exist("direct to video",mr->kd) == 1) {
           if (mr->pd->origin != NULL) {
             free(mr->pd->origin);
           }
           mr->pd->origin = (char *) calloc(40, sizeof(char));
           strcpy(mr->pd->origin,"Direct to Video");
    }
    else

         /* Always fails here when trying to diallocate mr->pd->origin */
         /* Note, that it does not fail the first time it hits the
statement, */
         /* but rather after some time */

         if (mr->pd->origin != NULL) {
          free(mr->pd->origin);
        }
        mr->pd->origin = (char *) calloc(40, sizeof(char));
        strcpy(mr->pd->origin,"");
  }

  mr = mr->next;

        keyword_exist(+kword, +kd)
        Return : True/False
 ****************************************************************/

int keyword_exist(char *kword, keyword_data *kd)
{
   while (kd != NULL) { if (strcmp(kword,kd->name) == 0) return(1); else kd
= kd->next; }
   return(0);

         {

The lack of a test on the result of each calloc() is more likely
to be the source of the problem.  If your system runs out of memory
"after some time", one of the calloc() calls might return NULL, and
then a subsequent strcpy() could scramble something.

The most likely problem, however, is somewhere else entirely.

Nonetheless, the above code could be considerably simplified.
Consider this replacement:

    some_type *pd;
    keyword_data *kd;
    char *newtext;

    for (mr = head; mr != NULL; mr = mr->next) {
        pd = mr->pd;
        if (pd == NULL) /* what does a NULL "pd" mean anyway? */
            continue;
        kd = mr->kd;
        if (keyword_exist("made for TV"), kd)
            newtext = "Made for TV";
        else if (keyword_exist("made for cable", kd))
            newtext = "Made for Cable";
        else if (keyword_exist("direct to video", kd))
            newtext = "Direct to Video";
        else
            newtext = "";
        if (pd->origin != NULL)
            free(pd->origin);

        /*
         * There is no obvious reason to use exactly 40 bytes per string
         * (for instance, you could malloc strlen(newtext)+1 bytes), but
         * I have retained this behavior anyway.
         */
        pd->origin = malloc(40);
        if (pd->origin == NULL)
            panic("failed to allocate 40 bytes");
        assert(strlen(newtext) < 40);
        strcpy(pd->origin, newtext);
    }

    int keyword_exist(/*const*/ char *kword, keyword_data *kd) {
        for (; kd != NULL; kd = kd->next)
            if (strcmp(kword, kd->name) == 0)
                return 1;
        return 0;
    }

or perhaps even:

    int keyword_exist(/*const*/ char *kword, keyword_data *kd) {
        for (; kd != NULL && strcmp(kword, kd->name) != 0; kd = kd->next)
            continue;
        return kd != NULL;
    }