1 files changed, 607 insertions, 0 deletions
diff --git a/dl_init_download.c b/dl_init_download.c
new file mode 100644
index 0000000..92dc9c8
--- /dev/null
+++ b/dl_init_download.c
@@ -0,0 +1,607 @@
+/* 
+ * Copyright 1996-2002 - Karl R. Hakimian and David Fries
+ *
+ * This file is part of datalink.
+ *
+ * Datalink is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Datalink is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with datalink (see COPYING); if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "datalink.h"
+#include "datalink_private.h"
+
+int
+dl_init_download(WatchInfoPtr wi, ListPtr times, ListPtr alarms,
+	ListPtr chron, ListPtr timers, ListPtr apps, ListPtr todos,
+	ListPtr phones, ListPtr annivs, ListPtr system, ListPtr wristapp,
+	ListPtr melody)
+{
+	ItemPtr ip;
+	char buf[1024];
+	int i;
+	int last_warn = 0;
+
+/* Free up old download structure if it exists. */
+	dl_free_download();
+
+	dl_download_data.memory = 0;
+	dl_download_data.app_size = 0;
+	dl_download_data.phone_size = 0;
+	dl_download_data.todo_size = 0;
+	dl_download_data.anniv_size = 0;
+	dl_download_data.pre_notification_time = wi->pre_notification_time;
+	dl_download_data.max_alarm_str = wi->max_alarm_str;
+	dl_download_data.max_timer_str = wi->max_timer_str;
+	dl_download_data.max_phone_str = wi->max_phone_str;
+	dl_download_data.max_chron_str = wi->max_chron_str;
+
+/* Count and verify items. */
+	if (times && times->download)
+	{
+
+		for (i = 0, ip = times->first; ip; ip = ip->next, i++)
+		{
+
+			if (!ip->data.time.tz_num)
+				ip->data.time.tz_num = i + 1;
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad time item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_tz)
+				return ((*dl_error_proc)
+					("Too many time items."));
+
+		}
+
+		if (i != times->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Time count value incorrect.");
+			times->count = i;
+		}
+
+	}
+
+	if (chron && chron->download)
+	{
+
+		for (i = 0, ip = chron->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad chron item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_chrons)
+				return ((*dl_error_proc)
+					("Too many chron items."));
+
+		}
+
+		if (i != chron->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Chron count value incorrect.");
+			chron->count = i;
+		}
+
+	}
+
+	if (alarms && alarms->download)
+	{
+
+		for (i = 0, ip = alarms->first; ip; ip = ip->next, i++)
+		{
+
+			if (!ip->data.alarm.alarm_num)
+				ip->data.alarm.alarm_num = i + 1;
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad alarm item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_alarms)
+				return ((*dl_error_proc)
+					("Too many alarm items."));
+
+		}
+
+		if (i != alarms->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Alarm count value incorrect.");
+			alarms->count = i;
+		}
+
+	}
+
+	if (timers && timers->download)
+	{
+
+		for (i = 0, ip = timers->first; ip; ip = ip->next, i++)
+		{
+
+			if (!ip->data.timer.timer_num)
+				ip->data.timer.timer_num = i + 1;
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad timer item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_timers)
+				return ((*dl_error_proc)
+					("Too many timer items."));
+
+		}
+
+		if (i != timers->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Timer count value incorrect.");
+			timers->count = i;
+		}
+
+	}
+
+	if (apps && apps->download)
+	{
+
+		for (i = 0, ip = apps->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad appointment item #%d",
+					i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_apps)
+				return ((*dl_error_proc)
+					("Too many appointment items."));
+
+			dl_download_data.memory += dl_sizeof_item(wi, ip);
+			dl_download_data.app_size +=
+			    dl_sizeof_item(wi, ip);
+		}
+
+		if (i != apps->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Appointment count value incorrect.");
+			apps->count = i;
+		}
+
+	}
+
+	if (todos && todos->download)
+	{
+
+		for (i = 0, ip = todos->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad todo item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_todos)
+				return ((*dl_error_proc)
+					("Too many todo items."));
+
+			dl_download_data.memory += dl_sizeof_item(wi, ip);
+			dl_download_data.todo_size +=
+			    dl_sizeof_item(wi, ip);
+		}
+
+		if (i != todos->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("To Do count value incorrect.");
+			todos->count = i;
+		}
+
+	}
+
+	if (phones && phones->download)
+	{
+
+		for (i = 0, ip = phones->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad phone item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_phones)
+				return ((*dl_error_proc)
+					("Too many phone items."));
+
+			dl_download_data.memory += dl_sizeof_item(wi, ip);
+			dl_download_data.phone_size +=
+			    dl_sizeof_item(wi, ip);
+		}
+
+		if (i != phones->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Phone count value incorrect.");
+			phones->count = i;
+		}
+
+	}
+
+	if (annivs && annivs->download)
+	{
+
+		for (i = 0, ip = annivs->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad anniversary item #%d",
+					i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_annivs)
+				return ((*dl_error_proc)
+					("Too many anniversary items."));
+
+			dl_download_data.memory += dl_sizeof_item(wi, ip);
+			dl_download_data.anniv_size +=
+			    dl_sizeof_item(wi, ip);
+		}
+
+		if (i != annivs->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Anniversary count value incorrect.");
+			annivs->count = i;
+		}
+
+	}
+
+	if (system && system->download)
+	{
+
+		for (i = 0, ip = system->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad sytem item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_system)
+				return ((*dl_error_proc)
+					("Too many sytem items."));
+
+		}
+
+		if (i != system->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("System count value incorrect.");
+			system->count = i;
+		}
+
+	}
+
+	if (wristapp && wristapp->download)
+	{
+
+		for (i = 0, ip = wristapp->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad wristapp item #%d",
+					i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_wristapp)
+				return ((*dl_error_proc)
+					("Too many wristapp items."));
+
+		}
+
+		if (i != wristapp->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("WristApp count value incorrect.");
+			wristapp->count = i;
+		}
+
+	}
+
+	if (melody && melody->download)
+	{
+
+		for (i = 0, ip = melody->first; ip; ip = ip->next, i++)
+		{
+
+			if (!dl_item_ok(wi, ip))
+			{
+				sprintf(buf, "Bad melody item #%d", i + 1);
+				return ((*dl_error_proc) (buf));
+			}
+
+			if (i >= wi->max_melody)
+				return ((*dl_error_proc)
+					("Too many melody items."));
+
+		}
+
+		if (i != melody->count)
+		{
+			last_warn =
+			    (*dl_warn_proc)
+			    ("Melody count value incorrect.");
+			melody->count = i;
+		}
+
+	}
+
+/* Check to see if memory usage has been exceeded. */
+
+	if (dl_download_data.memory > wi->max_mem)
+		return ((*dl_error_proc) ("Too much data."));
+
+/* OK. We know we have valid data that will fit in the watch. Allocate
+   download structure. */
+
+	if (times && times->download)
+	{
+
+		if ((dl_download_data.times =
+		     (TimePtr) calloc(times->count, sizeof(Time))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate time download data."));
+
+		dl_download_data.num_times = times->count;
+
+		for (i = 0, ip = times->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.times[i],
+			       (char *) &ip->data.time, sizeof(Time));
+		}
+
+	}
+
+	if (chron && chron->download)
+	{
+
+		if ((dl_download_data.chron =
+		     (ChronPtr) calloc(chron->count,
+				       sizeof(Chron))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate chron download data."));
+
+		dl_download_data.num_chron = chron->count;
+
+		for (i = 0, ip = chron->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.chron[i],
+			       (char *) &ip->data.chron, sizeof(Chron));
+			dl_download_data.chron[i].memused =
+			    14 + 4 * dl_download_data.chron[i].chron_laps;
+		}
+
+	}
+
+	if (alarms && alarms->download)
+	{
+
+		if ((dl_download_data.alarms =
+		     (AlarmPtr) calloc(alarms->count,
+				       sizeof(Alarm))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate alarm download data."));
+
+		dl_download_data.num_alarms = alarms->count;
+
+		for (i = 0, ip = alarms->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.alarms[i],
+			       (char *) &ip->data.alarm, sizeof(Alarm));
+		}
+
+	}
+
+	if (timers && timers->download)
+	{
+
+		if ((dl_download_data.timers =
+		     (TimerPtr) calloc(timers->count,
+				       sizeof(Timer))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate timer download data."));
+
+		dl_download_data.num_timers = timers->count;
+
+		for (i = 0, ip = timers->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.timers[i],
+			       (char *) &ip->data.timer, sizeof(Timer));
+		}
+
+	}
+
+	if (apps && apps->download)
+	{
+
+		if ((dl_download_data.apps =
+		     (AppointmentPtr) calloc(apps->count,
+					     sizeof(Appointment))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate appointment download data."));
+
+		dl_download_data.num_apps = apps->count;
+
+		for (i = 0, ip = apps->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.apps[i],
+			       (char *) &ip->data.app,
+			       sizeof(Appointment));
+		}
+
+	}
+
+	if (todos && todos->download)
+	{
+
+		if ((dl_download_data.todos =
+		     (ToDoPtr) calloc(todos->count, sizeof(ToDo))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate todo download data."));
+
+		dl_download_data.num_todos = todos->count;
+
+		for (i = 0, ip = todos->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.todos[i],
+			       (char *) &ip->data.todo, sizeof(ToDo));
+		}
+
+	}
+
+	if (phones && phones->download)
+	{
+
+		if ((dl_download_data.phones =
+		     (PhonePtr) calloc(phones->count,
+				       sizeof(Phone))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate phone download data."));
+
+		dl_download_data.num_phones = phones->count;
+
+		for (i = 0, ip = phones->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.phones[i],
+			       (char *) &ip->data.phone, sizeof(Phone));
+		}
+
+	}
+
+	if (annivs && annivs->download)
+	{
+
+		if ((dl_download_data.annivs =
+		     (AnniversaryPtr) calloc(annivs->count,
+					     sizeof(Anniversary))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate anniversary download data."));
+
+		dl_download_data.num_annivs = annivs->count;
+
+		for (i = 0, ip = annivs->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.annivs[i],
+			       (char *) &ip->data.anniv,
+			       sizeof(Anniversary));
+		}
+
+	}
+
+	if (system && system->download)
+	{
+
+		if ((dl_download_data.system =
+		     (SystemPtr) calloc(system->count,
+					sizeof(System))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate system download data."));
+
+		dl_download_data.num_system = system->count;
+
+		for (i = 0, ip = system->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.system[i],
+			       (char *) &ip->data.system, sizeof(System));
+		}
+
+	}
+
+	if (wristapp && wristapp->download)
+	{
+
+		if ((dl_download_data.wristapp =
+		     (WristAppPtr) calloc(wristapp->count,
+					  sizeof(WristApp))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate wristapp download data."));
+
+		dl_download_data.num_wristapp = wristapp->count;
+
+		for (i = 0, ip = wristapp->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.wristapp[i],
+			       (char *) &ip->data.wristapp,
+			       sizeof(WristApp));
+		}
+
+	}
+
+	if (melody && melody->download)
+	{
+
+		if ((dl_download_data.melody =
+		     (MelodyPtr) calloc(melody->count,
+					sizeof(Melody))) == NULL)
+			return ((*dl_error_proc)
+				("Can't allocate melody download data."));
+
+		dl_download_data.num_melody = melody->count;
+
+		for (i = 0, ip = melody->first; ip; ip = ip->next, i++)
+		{
+			memcpy((char *) &dl_download_data.melody[i],
+			       (char *) &ip->data.melody, sizeof(Melody));
+		}
+
+	}
+
+	return (0);
+}