fixing extensions
[feisty_meow.git] / octopi / library / octopus / infoton.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : infoton                                                           *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 2002-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "infoton.h"
16
17 #include <basis/functions.h>
18 #include <loggers/critical_events.h>
19 #include <loggers/program_wide_logger.h>
20 #include <structures/string_array.h>
21 #include <textual/byte_formatter.h>
22
23 using namespace basis;
24 using namespace loggers;
25 using namespace structures;
26 using namespace textual;
27
28 namespace octopi {
29
30 #undef LOG
31 #define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
32
33 //#define DEBUG_INFOTON
34   // if uncommented, then extra checks are made.
35
36 const abyte FAST_PACK_VERSION = 0x14;
37   // this single byte version number should be increased when the network
38   // protocol changes.  it only ensures that the fast_pack method will reject
39   // a lower version.
40
41 infoton::infoton(const string_array &classifier)
42 : _classifier(new string_array(classifier))
43 {
44   FUNCDEF("constructor [string_array]");
45 }
46
47 infoton::infoton(const astring &class_1)
48 : _classifier(new string_array)
49 {
50   FUNCDEF("constructor [one string]");
51   *_classifier += class_1;
52 }
53
54 infoton::infoton(const astring &class_1, const astring &class_2)
55 : _classifier(new string_array)
56 {
57   FUNCDEF("constructor [two strings]");
58   *_classifier += class_1;
59   *_classifier += class_2;
60 }
61
62 infoton::infoton(const astring &class_1, const astring &class_2,
63     const astring &class_3)
64 : _classifier(new string_array)
65 {
66   FUNCDEF("constructor [three strings]");
67   *_classifier += class_1;
68   *_classifier += class_2;
69   *_classifier += class_3;
70 }
71
72 infoton::infoton(const infoton &to_copy)
73 : root_object(),
74   packable(),
75   clonable(),
76   _classifier(new string_array(*to_copy._classifier))
77 {}
78
79 infoton::~infoton()
80 { WHACK(_classifier); }
81
82 infoton &infoton::operator = (const infoton &to_copy)
83 { *_classifier = *to_copy._classifier; return *this; }
84
85 const string_array &infoton::classifier() const
86 { return *_classifier; }
87
88 bool infoton::check_classifier(const astring &classname, const astring &caller)
89 {
90   bool to_return = true;
91   if (!_classifier->length())
92     to_return = false;
93   for (int i = 0; i < _classifier->length(); i++) {
94     if (!(*_classifier)[i].length())
95       to_return = false;
96   }
97   if (!to_return) {
98     program_wide_logger::get().log(classname + "::" + caller
99         + ": invalid classifier provided.", ALWAYS_PRINT);
100   }
101   return to_return;
102 }
103
104 void infoton::set_classifier(const string_array &new_classifier)
105 {
106 #ifdef DEBUG_INFOTON
107   FUNCDEF("set_classifier [string_array]");
108 #endif
109   *_classifier = new_classifier;
110 #ifdef DEBUG_INFOTON
111   check_classifier(class_name(), func);
112 #endif
113 }
114
115 void infoton::set_classifier(const astring &class_1)
116 {
117 #ifdef DEBUG_INFOTON
118   FUNCDEF("set_classifier [1 string]");
119 #endif
120   _classifier->reset();
121   *_classifier += class_1;
122 #ifdef DEBUG_INFOTON
123   check_classifier(class_name(), func);
124 #endif
125 }
126
127 void infoton::set_classifier(const astring &class_1, const astring &class_2)
128 {
129 #ifdef DEBUG_INFOTON
130   FUNCDEF("set_classifier [2 strings]");
131 #endif
132   _classifier->reset();
133   *_classifier += class_1;
134   *_classifier += class_2;
135 #ifdef DEBUG_INFOTON
136   check_classifier(class_name(), func);
137 #endif
138 }
139
140 void infoton::set_classifier(const astring &class_1, const astring &class_2,
141     const astring &class_3)
142 {
143 #ifdef DEBUG_INFOTON
144   FUNCDEF("set_classifier [3 strings]");
145 #endif
146   _classifier->reset();
147   *_classifier += class_1;
148   *_classifier += class_2;
149   *_classifier += class_3;
150 #ifdef DEBUG_INFOTON
151   check_classifier(class_name(), func);
152 #endif
153 }
154
155 int infoton::fast_pack_overhead(const string_array &classifier)
156 {
157   return classifier.packed_size()  // for classifier.
158       + sizeof(int)  // for the package size.
159       + 1;  // for the version byte.
160 }
161
162 void infoton::fast_pack(byte_array &packed_form, const infoton &to_pack)
163 {
164   FUNCDEF("fast_pack");
165   structures::attach(packed_form, FAST_PACK_VERSION);
166     // add the tasty version byte as the very first item.
167   structures::pack_array(packed_form, to_pack.classifier());
168   // must first put the packed infoton into a byte array, then use the
169   // byte array's packing support.
170   int len_prior = packed_form.length();
171   structures::attach(packed_form, int(0));
172     // save space for length.
173 //hmmm: this could use obscure_pack for more reliability.
174   to_pack.pack(packed_form);
175   int added_len = packed_form.length() - sizeof(int) - len_prior;
176
177   // shift in the length in the place where we made space.
178   basis::un_int temp = basis::un_int(added_len);
179   for (basis::un_int i = 0; i < sizeof(int); i++) {
180     packed_form[len_prior + i] = abyte(temp % 0x100);
181     temp >>= 8;
182   }
183 }
184
185 bool infoton::test_fast_unpack(const byte_array &packed_form,
186     int &packed_length)
187 {
188   FUNCDEF("test_fast_unpack");
189   packed_length = 0;
190   if (!packed_form.length()) return false;
191
192   // make sure we have the right version number, first.
193   if (packed_form[0] != FAST_PACK_VERSION)
194     return false;
195
196   un_int strings_held = 0;
197   byte_array len_bytes = packed_form.subarray(1, 2 * sizeof(int));
198   if (!structures::obscure_detach(len_bytes, strings_held) || !strings_held) {
199     return false;
200   }
201
202   // check through all of the strings.
203   const void *zero_posn = packed_form.observe() + sizeof(int) * 2 + 1;
204   for (int i = 0; i < (int)strings_held; i++) {
205     // locate the zero termination if possible.
206     int index = int((abyte *)zero_posn - packed_form.observe());
207     zero_posn = memchr(packed_form.observe() + index, '\0',
208         packed_form.length() - index);
209     // make sure we could find the zero termination.
210     if (!zero_posn) {
211       // nope, never saw a zero.  good thing we checked.
212       return false;
213     }
214   }
215
216   // base our expected position for the data length on the position of the
217   // last string we found.
218   int datalen_start = int((abyte *)zero_posn - packed_form.observe()) + 1;
219   byte_array just_len = packed_form.subarray(datalen_start,
220       datalen_start + sizeof(int) - 1);
221   if (!structures::detach(just_len, packed_length)) return false;
222   packed_length += datalen_start + sizeof(int);
223     // include the classifier length and integer package length.
224   return true;
225 }
226
227 bool infoton::fast_unpack(byte_array &packed_form, string_array &classifier,
228     byte_array &info)
229 {
230   FUNCDEF("fast_unpack");
231   classifier.reset();
232   info.reset();
233   abyte version_checking = 0;
234   if (!structures::detach(packed_form, version_checking)) return false;
235   if (version_checking != FAST_PACK_VERSION) return false;
236   if (!structures::unpack_array(packed_form, classifier)) return false;
237   int len = 0;
238   if (!structures::detach(packed_form, len)) return false;
239   if (len > packed_form.length()) {
240     // not enough data.
241     continuable_error(static_class_name(), func, "failed to have enough data!");
242     return false;
243   }
244   info = packed_form.subarray(0, len - 1);
245   packed_form.zap(0, len - 1);
246   return true;
247 }
248
249 } //namespace.
250