blendjob_ptr->total_frames);

	      abort();

	    }

	}

      general_info.rendering_clients = workers_working; /*< should this be a +=? */

      blendjob_ptr = blendjob_ptr->next; /*< This is the essence of linked lists and iterating through them */

      numjobs ++;

    } /* while(blendjob_ptr) */

  general_info.jobs_in_queue = (highest_jobnum - general_info.total_finished_jobs); /*< extraneous parentheses! */

}

// **** Structure Builder: This function creates frame array based on the total number of frames to be rendered, which will then be parsed by function frame_farmer.

void frame_num_struct_builder(struct blendjob *job, unsigned int startframe, unsigned int numframes) {

  int jobnum_new = highest_jobnum + 1; /* global vars will someday leave us  */

  unsigned int counter;

	job->frameset = malloc(sizeof(struct frameset) * numframes);

	if(!job->frameset)

	  fprintf(stderr, "error allocating memory");

	job->total_frames = numframes; // sets the total number of frames in animation for status purposes

	job->jobnum = jobnum_new;

	for(counter = 0; counter < numframes; counter ++)

	  /* This builds the array, with the array starting at zero and the frameset.num starting at sframe */

	  job->frameset[counter].num = counter + startframe;

	highest_jobnum++; // After it has created the job, it adds one to the highest_jobnum interger

}

/**

  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

*/

int frame_finder(struct blendjob *head, struct blendjob **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

  unsigned short int found;

  unsigned short int priority;

  struct blendjob *blendjob_ptr;

  found = 0;

  while(!found)

    {

      /* enumerate through priority levels */

      for(priority = 10;

	  priority > 0

	    && !found;

	  priority --)

	/* Find the job with the highest priority */

	for(blendjob_ptr = head;

	    blendjob_ptr != NULL

	      && !found;

	    blendjob_ptr = blendjob_ptr->next)

	  if(blendjob_ptr->priority == priority)

	    found = 1;

      if(!found)

	{

	  fprintf(stderr, "out of jobs to render\n");

	  return 1;

	}

      found = 0;

      for(your_frame = 0;

	  your_frame < blendjob_ptr->total_frames;

	  your_frame ++)

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

	  found = 1;

      if(!found)

	{

	  /* there are no frames left in this job */

	  blendjob_ptr->priority --;

	  /* If that job had no open frames for some reason, run the status report generator so that */

	  status_report_generator(&head);

	  /* should the job be removed now? */

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

	}

    } /* while(!found) */

		      ,

		      CFGF_MULTI),

	      CFG_END()

	    };

	  config = malloc(sizeof(struct distrend_config));

	  options_init(argc, argv, &config->mycfg, myopts, "server", &config->options);

	  return 0;

	}

	int distrend_config_free(struct distrend_config *config)

	{

	  options_free(config->options);

	  free(config);

	  return 0;

	}

// End non-working framework?

int main(int argc, char *argv[])

{

  /* TODO: Put some arg-grabbing code here */

  struct blendjob *head;

  int cont;

  struct distrend_listenset *listenset;

  struct distrend_config *config;

  enum clientstatus

  {

    CLIENTSTATUS_UNINITIALIZED = 0,

    CLIENTSTATUS_BUSY = 1,

    CLIENTSTATUS_IDLE = 2

  } clientstatus;

  head = NULL;

  cont = 1;

  distrend_do_config(argc, argv, config);

  distrend_listen(&listenset, config);

  /* This is called the ``main loop'' */

  while(cont)

    {

      struct distren_action *action;

      int clientsays; /*< temporary example variable, will be replaced when we can handle messages */

      distrend_accept(&action);

      cont = distrend_do(action);

      /* Somewhat Pseudo-code for basic server operation, should be more event-driven */

      start_data();

      status_report_generator(&head);

      blend_frame_watchdog(head);

      struct frameset *frame;

      struct blendjob *job;

      /* If the client is idle (meaning a client without the "busy" status connected via ssh), all clients should be idle by default. */

      if(clientstatus == CLIENTSTATUS_IDLE)

	{

	  /**

	      normaldotcom: learn about ``return by pointer''

	  */

	  int returnnum = frame_finder(head, &job, &frame); // give framefinder args, framefinder should return job number and frame number somehow

	  if(returnnum)

	    {

	      fprintf(stderr,"No frames are available to render at this time");

	      sleep(10);

	    }

	  else

	    /* returnnum == 0 */

	    remotio_send_to_client(frame->num, job->jobnum); // Did you actually make this function, ohnobinki? --normaldotcom

	}

      /* If the client states that they finished the frame */

      	if(clientsays == DISTREN_REQUEST_DONEFRAME){

      		clientstatus = CLIENTSTATUS_IDLE; // Sets the client back to idle

      	}

      /* End Somewhat Pseudo-code */

      distrend_action_free(action);

    }

  distrend_unlisten(listenset);

  distrend_config_free(config);

  return 0;

}