struct distrenjob *prev_job = head; // create pointer to previous job

  struct distrenjob *current_job;     // create pointer to current_job (which job is being compared to)

  // iterate through linked list of jobs

  for(current_job = head; current_job != NULL; current_job = current_job->next){

    if(current_job == NULL){ // if it has reached the end of the list, add job there

      current_job = job;

      break;

    }

    else if(job->priority < current_job->priority){ // if job's priority is less than current_job's priority, insert job

      prev_job->next = job;                        // keep in mind 1 is the highest priority given to jobs, head has a

      job->next = current_job;                     // priority of zero so it will always be before other jobs

      break;

    }

    prev_job = current_job;

  } /* for(current_job) */

}

/**

   @arg head I may end up changing the head if job == head

 */

void change_job_priority(struct distrenjob *head, struct distrenjob *job, int new_priority){

  distrenjob_remove(head, job);

  job->priority = new_priority;

  struct distrenjob *current_job;

  struct distrenjob *prev_job = head;

  if(job->frameset[0].status == 0){ // if job was not yet started

    distrenjob_enqueue(head, job);

  }

  else{ // if job has already been started then place it before the jobs with the same priority

    // iterate through linked list of jobs

    for(current_job = head; current_job != NULL; current_job = current_job->next){

      if(current_job == NULL){ // if it has reached the end of the list, add job there

        current_job = job;

        break;

      }

      else if(job->priority <= current_job->priority){ // if job's priority is less than or equal to current_job's priority, insert job

        prev_job->next = job;                        // keep in mind 1 is the highest priority given to jobs, head has a

        job->next = current_job;                     // priority of zero so it will always be before other jobs

        break;

      }

      prev_job = current_job;

    }

  }

}

/**

  Frame Finder: matches your computer up with a lovely frame to render

  TODO: Major issue here, the client needs to know the frame number, AND the job number!

  Notice that this function starts by looking at the oldest job first

	TODO: Link this up with the main() function to check if there are frames available or not and provide jobnum/framenum to the client

  @return 0 success, other: error

*/

/*@TODO: change frame_finder to job_finder */

int frame_finder(struct distrenjob *head, struct distrenjob **job, struct frameset **frame)

{

  int your_frame;  // your_frame is an integer value that will be given to the client as the frame number to render

  short int your_job_type;

  unsigned short int found;

  struct distrenjob *distrenjob_ptr;

  your_frame = 0;

  your_job_type = 0;

  found = 0;

  /* iterate through jobs from first to last */

  for(distrenjob_ptr = head->next; !found && !distrenjob_ptr; distrenjob_ptr = distrenjob_ptr->next)

    {

      // while frame hasn't been found, and your_frame is less than the length of the frameset array

      for(your_frame; !found && your_frame < distrenjob_ptr->total_frames; your_frame++)

        {

          if(distrenjob_ptr->frameset[your_frame].status == 0)

            {

              found = 1;

              your_job_type = distrenjob_ptr->type;

              distrenjob_ptr->frameset[your_frame].status = 1;

              distrenjob_ptr->frameset[your_frame].start_time = clock();

              break;

            }

        }

    }

// end of while statement... job must be found or linked list must be ended to get out of here

      if(!found)

        {

          fprintf(stderr, "No more jobs to render\n");

          return 1;

        }

    // the actual frame number to be rendered by the client is start_frame + your_frame

      /* should the job be removed now? ANSWER: well, if a computer decides not to return their frame then we lost our data... so its not done yet. */

      fprintf(stderr, "Job %d is finished, this is probably the place to call the job-removal function\n", distrenjob_ptr->jobnum);

      /* @TODO: At this point, all slaves should be instructed to delete the source data for this job. */

  return 0;

}

/** Checks for dead, laggy, or stale slaves */

void blend_frame_watchdog(struct distrenjob *distrenjob_head)

{

  unsigned short int watchdog_forgiveness; /*< seconds to wait on a frame before re-assigning it */

  struct distrenjob *distrenjob_ptr;

  unsigned int counter;

  watchdog_forgiveness = 1; /*< hours of forgiveness before frame is re-assigned @TODO: Make this more user-configurable (maybe per-job), 3 hours is a LONG time */

  distrenjob_ptr = distrenjob_head;

  for(distrenjob_ptr = distrenjob_head; distrenjob_ptr; distrenjob_ptr = distrenjob_ptr->next)

    /* iterate through jobs */

    for(counter = 0; counter < distrenjob_ptr->total_frames; counter ++)

      /* iterate through all frames for this job*/

      {

        if((distrenjob_ptr->frameset[counter].start_time + (watchdog_forgiveness * 3600)) < clock())

          /*

            If frame is not completed within the number of hours specified by watchdog_forgiveness

            Then change the frame status to unassigned

           */

          distrenjob_ptr->frameset[counter].status = 0;

      }

}

/**

   Finds a distrenjob struct based on the jobnum

   @arg jobnum job number to search for

   @return NULL on job doesn't exist

 */

struct distrenjob *distrenjob_get(struct distrenjob *head, jobnum_t jobnum)

{

  struct distrenjob *distrenjob_ptr;

  /*

    The conditions of the for loop will leave distrenjob_ptr at NULL if the end of the list is reached. It will leave it pointing to the correct job if it is found.

   */

  for(distrenjob_ptr = head;

      distrenjob_ptr

        && distrenjob_ptr->jobnum != jobnum;

      distrenjob_ptr = distrenjob_ptr->next);

  return distrenjob_ptr;

}

/**

   Removes a distrenjob from the distrenjob linked list.

   @arg head a double pointer. the head pointer will have to be changed if distrenjob == *head. Thus, make sure that the pointer points to the pointer to the head that all functions use. (I'm going to come back to this and misunderstand myself ;-))

 */

void distrenjob_remove(struct distrenjob **head, struct distrenjob *bj)

{

  struct distrenjob *previous_distrenjob;

  if(bj == *head)

    *head = bj->next;

  else

    {

      for(previous_distrenjob = *head;

        previous_distrenjob

          && previous_distrenjob->next != bj; /*< stop on the distrenjob that comes before bj */

          previous_distrenjob = previous_distrenjob->next)

	/* all of the action is in the definition of the for loop itself */;

      /*

	This removes references to bj from the linked list. I.E., we now skip bj when iterating through the list

       */

      previous_distrenjob->next = bj->next;

    }

}

/* Grabs config info from confs */

int distrend_do_config(int argc, char *argv[], struct distrend_config **config)

{

  cfg_opt_t myopts_listen[] =

    {

      CFG_SIMPLE_STR("type", NULL),

      CFG_SIMPLE_STR("path", NULL),

      CFG_SIMPLE_INT("port", NULL),

      CFG_END()

    };

  cfg_opt_t myopts[] =

    {

      CFG_SEC("listen",  /* this must be imported into struct listens (which must still be declared) */