Address 1:  state=1, next=2
Address 2: state=0, next=NULL

// descr **p is pointless, returning a pointer is much less likely
// to be screwed up.
int initialize_descr(int newfd)
{
 struct descr *d=descr_list;

 // why are there absolutely no comments in your code?
 if( d != NULL)
 {
  while(d->next != NULL)
   d = d->next;

  if(!(d->next = malloc(sizeof(struct descr))))
  {
   nonfatal("malloc failure initializing descr");
   return 0;
  }

  d = d->next;
 }
 // We only allocate this memory when the list is empty.
 // But you forgot to put it into descr_list.
 // So the list will always stay empty!
 else if(!(d = malloc(sizeof(struct descr))))
 {
  nonfatal("malloc failure initializing descr");
  return 0;
 }
 d->newfd = newfd;
 d->state = 1;
 if(!(d->q = malloc(sizeof(struct descr))))
 {
  nonfatal("malloc failure initializing descr queue");
  d->state = 0;
  return 0;
 }
 d->q->next = NULL;
 d->next = NULL;
*p = d;
}

struct descr *initialize_descr(int newfd, struct descr **p)
{
 struct descr *d=descr_list;

 if(d == NULL)
 {
    // The base of the list itself must be updated.
    descr_list=malloc(sizeof(struct descr));
    // then set our own pointer to it too.
    d=descr_list;
    // if malloc failed, return error.
    if(d == NULL) return(NULL);
 }
 else
 {
    // find the end of the list.
    while(d->next != NULL) d=d->next;

    d->next=malloc(sizeof(struct descr));
    // if malloc failed, return error
    if(d->next == NULL) return(NULL);
    // set d to the memory we just allocated.
    d=d->next;
 }

 d->newfd = newfd;
 d->state = 1;

 if(!(d->q = malloc(sizeof(struct descr))))
 {
  nonfatal("malloc failure initializing descr queue");
  d->state = 0;
  return 0;
 }
 d->q->next = NULL;
 d->next = NULL;
 return(d);
}

struct descr
{
 short int newfd;
 short int state; /* Maximum states allowed, 65536 */
 struct queue *q;
 struct descr *next;
struct descr *self;
};

int readjust_descr()
{
 struct descr *r, *track;
 track = descr_list;
    while(descr_list != NULL)
    {
     if(descr_list->state = 0)
     {
         r=descr_list;
         free(descr_list);
     }
     descr_list = descr_list->next;
    }
    descr_list = track;
}

#include <stdio.h>
#include <stdlib.h>

struct descr
{
    int state;
    struct descr *next;
};

// We pass a pointer to the head pointer for the list since we may need to
// change it.
struct descr *append_list(struct descr **head, int state) // Add new thing to the end
{
    struct descr *list;
    // Create new node
    struct descr *n=malloc(sizeof(struct descr));
    if(n == NULL) return(NULL); // Return error if malloc failed.

    n->state=state;
    n->next=NULL;

    // Empty list?  Set head and we're done.
    if((*head) == NULL)
    {
        (*head)=n;
        return(n); // return success
    }

    list=(*head); // set list to the first node.

    // We know the list must not be empty now.
    // Fast-forward until we're at the last descr.
    while(list->next != NULL) list=list->next;

    // Set the 'next' of the last descr to the new descr.
    list->next=n;

    // 'head' is fine where it is, so we're all done.
    return(n);
}

// Deletes all nodes set to the number 'state'.
int delete_state(struct descr **head, int state)
{
    struct descr *list;
    if((*head) == NULL) return(1); // Nothing to do when empty, but that's okay

    // If the list goes 0-> 0-> 0-> 0, we'll need to delete
    // the first node over and over.  After we delete, the second
    // becomes the first, so we start over.
    while((*head)->state == state)
    {
        struct descr *tmp=(*head)->next;
        free(*head); // Free the first node in the list
        (*head)=tmp; // Set the head pointer to the new first node

        if((*head) == NULL) return(1); // If list==NULL here, the list is empty and we're done!
    }

    // Below here, we're no longer changing the first node, so don't have to
    // worry about updating (*head).
    list=(*head);

    while(list->next != NULL)
    {
        // Keep deleting the node after the current one until we find a node
        // we don't need to delete.  When we delete the node after,
        // the node after that becomes the new 'next', so it's a loop.
        while(list->next->state == state)
        {
            struct descr *tmp=list->next->next; // Save the node after
            free(list->next);
            list->next=tmp;
            // if list->next is NULL, list->next->state will CRASH!
            // So when it is, quit the loop immediately!
            if(list->next == NULL) break;
        }

        list=list->next;
        if(list == NULL) break; // NULL means we hit the end of the list and must stop NOW!
    }

    return(0);
}

void free_list(struct descr **head)
{
    while((*head) != NULL)
    {
        struct descr *tmp=(*head)->next;
        free(*head);
        (*head)=tmp;
    }
}

int main(void)
{
    struct descr *head=NULL; // This is the head pointer our functions change with '(*head)'
    struct descr *n, *a, *b, *c, *d, *e, *f; // These will point to nodes we make.

    // create a list 0->1->2->0->3->0
    a=append_list(&head, 0);
    b=append_list(&head, 1);
    c=append_list(&head, 2);
    d=append_list(&head, 0);
    e=append_list(&head, 3);
    f=append_list(&head, 0);

    e->state=4; // Update the '3' node to '4'

    // print each node.
    for(n=head; n!=NULL; n=n->next)
      printf("-> %d", n->state);
    printf("\n");

    // delete all nodes where state==0
    delete_state(&head, 0);

    // print it again.
    for(n=head; n!=NULL; n=n->next)
      printf("-> %d", n->state);
    printf("\n");

    // Beware that pointers a, d, and f are invalid now since
    // their memory was freed
    // Don't use f->state or anything now.

    // Free the entire list.  It will set head to NULL, too.
    free_list(&head);
}