Main Page | Class Hierarchy | Class List | File List | Class Members

cliproto.h

00001 //-< CLIPROTO.H >----------------------------------------------------*--------*
00002 // GigaBASE                  Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Post Relational Database Management System)                      *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     13-Jan-2000  K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 13-Jan-2000  K.A. Knizhnik  * GARRET *
00007 //-------------------------------------------------------------------*--------*
00008 // Client-server communication protocol
00009 //-------------------------------------------------------------------*--------*
00010 
00011 #ifndef __CLIPROTO_H__
00012 #define __CLIPROTO_H__
00013 
00014 BEGIN_GIGABASE_NAMESPACE
00015 
00016 enum cli_commands {
00017     cli_cmd_close_session,
00018     cli_cmd_prepare_and_execute,
00019     cli_cmd_execute,
00020     cli_cmd_get_first,
00021     cli_cmd_get_last,
00022     cli_cmd_get_next,
00023     cli_cmd_get_prev,
00024     cli_cmd_free_statement,
00025     cli_cmd_abort,
00026     cli_cmd_commit,
00027     cli_cmd_update,
00028     cli_cmd_remove,
00029     cli_cmd_insert,
00030     cli_cmd_prepare_and_insert,
00031     cli_cmd_describe_table,
00032     cli_cmd_show_tables,
00033     cli_cmd_login,
00034     cli_cmd_precommit, 
00035     cli_cmd_skip,
00036     cli_cmd_create_table,
00037     cli_cmd_drop_table,
00038     cli_cmd_alter_index,
00039     cli_cmd_freeze,
00040     cli_cmd_unfreeze,
00041     cli_cmd_seek,
00042     cli_cmd_alter_table,
00043     cli_cmd_last
00044 };
00045 
00046 static const int sizeof_type[] = {
00047     sizeof(cli_oid_t),
00048     sizeof(cli_bool_t),
00049     sizeof(cli_int1_t),
00050     sizeof(cli_int2_t),
00051     sizeof(cli_int4_t),
00052     sizeof(cli_int8_t),
00053     sizeof(cli_real4_t),
00054     sizeof(cli_real8_t),
00055     sizeof(cli_real8_t), // cli_decimal
00056     sizeof(char*), // cli_asciiz, 
00057     sizeof(char*), // cli_pasciiz,
00058     sizeof(char*), // cli_cstring,
00059     sizeof(cli_array_t), // cli_array_of_oid,
00060     sizeof(cli_array_t), // cli_array_of_bool,
00061     sizeof(cli_array_t), // cli_array_of_int1,
00062     sizeof(cli_array_t), // cli_array_of_int2,
00063     sizeof(cli_array_t), // cli_array_of_int4,
00064     sizeof(cli_array_t), // cli_array_of_int8,
00065     sizeof(cli_array_t), // cli_array_of_real4,
00066     sizeof(cli_array_t), // cli_array_of_real8, 
00067     sizeof(cli_array_t), // cli_array_of_decimal, 
00068     sizeof(cli_array_t), // cli_array_of_string,
00069     0, // cli_any,
00070     sizeof(cli_int8_t), // cli_datetime,
00071     sizeof(cli_int4_t), // cli_autoincrement,
00072     sizeof(cli_rectangle_t), // cli_rectangle,
00073     0  // cli_unknown
00074 };
00075 
00076 union cli_field_alignment {
00077     struct { char n; cli_oid_t v;  }  _cli_oid_t;
00078     struct { char n; cli_bool_t v;  } _cli_bool_t;
00079     struct { char n; cli_int1_t v;  } _cli_int1_t;
00080     struct { char n; cli_int2_t v;  } _cli_int2_t;
00081     struct { char n; cli_int4_t v;  } _cli_int4_t;
00082     struct { char n; cli_int8_t v;  } _cli_int8_t;
00083     struct { char n; cli_real4_t v; } _cli_real4_t;
00084     struct { char n; cli_real8_t v; } _cli_real8_t;
00085     struct { char n; cli_array_t v; } _cli_array_t;
00086     struct { char n; char*       v; } _cli_asciiz_t;
00087     struct { char n; cli_cstring_t v; } _cli_cstring_t;
00088     struct { char n; cli_rectangle_t v; } _cli_rectangle_t;
00089 };
00090 
00091 #define CLI_ALIGNMENT(type) \
00092         (((char *)&(((union cli_field_alignment*)0)->_##type.v)) - ((char *)&(((union cli_field_alignment*)0)->_##type.n)))
00093 
00094 static const int alignof_type[] = { 
00095     CLI_ALIGNMENT(cli_oid_t), 
00096     CLI_ALIGNMENT(cli_bool_t), 
00097     CLI_ALIGNMENT(cli_int1_t), 
00098     CLI_ALIGNMENT(cli_int2_t), 
00099     CLI_ALIGNMENT(cli_int4_t), 
00100     CLI_ALIGNMENT(cli_int8_t), 
00101     CLI_ALIGNMENT(cli_real4_t), 
00102     CLI_ALIGNMENT(cli_real8_t),
00103     CLI_ALIGNMENT(cli_real8_t),
00104     CLI_ALIGNMENT(cli_asciiz_t),
00105     CLI_ALIGNMENT(cli_asciiz_t),
00106     CLI_ALIGNMENT(cli_cstring_t),
00107     CLI_ALIGNMENT(cli_array_t), // cli_array_of_oid,
00108     CLI_ALIGNMENT(cli_array_t), // cli_array_of_bool,
00109     CLI_ALIGNMENT(cli_array_t), // cli_array_of_int1,
00110     CLI_ALIGNMENT(cli_array_t), // cli_array_of_int2,
00111     CLI_ALIGNMENT(cli_array_t), // cli_array_of_int4,
00112     CLI_ALIGNMENT(cli_array_t), // cli_array_of_int8,
00113     CLI_ALIGNMENT(cli_array_t), // cli_array_of_real4,
00114     CLI_ALIGNMENT(cli_array_t), // cli_array_of_real8, 
00115     CLI_ALIGNMENT(cli_array_t), // cli_array_of_decimal, 
00116     CLI_ALIGNMENT(cli_array_t), // cli_array_of_string,
00117     0, // cli_any,
00118     CLI_ALIGNMENT(cli_int8_t), // cli_datetime,
00119     CLI_ALIGNMENT(cli_int4_t), // cli_autoincrement,
00120     CLI_ALIGNMENT(cli_rectangle_t), // cli_rectangle,
00121     0  // cli_unknown
00122 };
00123 
00124 static const int gb2cli_type_mapping[] = {
00125     cli_bool,
00126     cli_int1,
00127     cli_int2,
00128     cli_int4,
00129     cli_int8,
00130     cli_real4,
00131     cli_real8,
00132     cli_asciiz,
00133     cli_oid
00134 };
00135 
00136 
00137 #if defined(__FreeBSD__)
00138 END_GIGABASE_NAMESPACE
00139 #include <sys/param.h>
00140 #include <netinet/in.h>
00141 BEGIN_GIGABASE_NAMESPACE
00142 #define USE_HTON_NTOH
00143 #elif defined(__linux__)
00144 //
00145 // At Linux inline assembly declarations of ntohl, htonl... are available
00146 //
00147 END_GIGABASE_NAMESPACE
00148 #include <netinet/in.h>
00149 BEGIN_GIGABASE_NAMESPACE
00150 #define USE_HTON_NTOH
00151 #else
00152 #if defined(_WIN32) && _M_IX86 >= 400 && !defined(__BCPLUSPLUS__) && !defined(__MINGW32__)
00153 #pragma warning(disable:4035) // disable "no return" warning
00154 #ifdef __BORLANDC__
00155 static
00156 #else
00157 inline 
00158 #endif
00159 int swap_bytes_in_dword(int val) {
00160     __asm {
00161           mov eax, val
00162           bswap eax
00163     }
00164 }
00165 #ifdef __BORLANDC__
00166 static
00167 #else
00168 inline 
00169 #endif
00170 short swap_bytes_in_word(short val) {
00171     __asm {
00172           mov ax, val
00173           xchg al,ah
00174     }
00175 }
00176 #pragma warning(default:4035)
00177 #define ntohl(w) swap_bytes_in_dword(w)
00178 #define htonl(w) swap_bytes_in_dword(w)
00179 #define ntohs(w) swap_bytes_in_word(w)
00180 #define htons(w) swap_bytes_in_word(w)
00181 
00182 #define USE_HTON_NTOH
00183 #endif
00184 #endif
00185 
00186 
00187 
00188 
00189 inline char* pack2(char* dst, int2 val) {
00190     *dst++ = char(val >> 8);
00191     *dst++ = char(val);
00192     return dst;
00193 }
00194 
00195 inline char* pack2(char* dst, char const* src) {
00196     return pack2(dst, *(int2*)src);
00197 }
00198 
00199 inline void pack2(int2& val) {
00200 #if BYTE_ORDER != BIG_ENDIAN
00201 #ifdef USE_HTON_NTOH
00202     val = htons(val);
00203 #else
00204     pack2((char*)&val, val);
00205 #endif
00206 #endif
00207 }
00208 
00209 
00210 inline char* pack4(char* dst, int4 val) {
00211     *dst++ = char(val >> 24);
00212     *dst++ = char(val >> 16);
00213     *dst++ = char(val >> 8);
00214     *dst++ = char(val);
00215     return dst;
00216 }
00217 
00218 inline char* pack4(char* dst, char const* src) {
00219     return pack4(dst, *(int4*)src);
00220 }
00221 
00222 inline void pack4(int4& val) {
00223 #if BYTE_ORDER != BIG_ENDIAN
00224 #ifdef USE_HTON_NTOH
00225     val = htonl(val);
00226 #else
00227     pack4((char*)&val, val);
00228 #endif
00229 #endif
00230 }
00231 
00232 
00233 inline char* pack8(char* dst, char const* src) {
00234 #if BYTE_ORDER == BIG_ENDIAN
00235     return pack4( pack4(dst, src), src + 4);
00236 #else
00237     return pack4( pack4(dst, src + 4), src);
00238 #endif
00239 }
00240 
00241 inline char* pack8(char* dst, db_int8 val) {
00242     return pack8(dst, (char*)&val);
00243 }
00244 
00245 inline char* pack_oid(char* dst, cli_oid_t oid)
00246 {
00247     return (sizeof(oid) == 4) ? pack4(dst, oid) : pack8(dst, (char*)&oid);
00248 }
00249 
00250 inline char* pack_rectangle(char* dst, cli_rectangle_t* rect)
00251 {
00252     if (sizeof(cli_coord_t) == 4) { 
00253         for (int i = 0; i < CLI_RECTANGLE_DIMENSION*2; i++) { 
00254             dst = pack4(dst, (char*)&rect->boundary[i]);
00255         }
00256     } else { 
00257         for (int i = 0; i < CLI_RECTANGLE_DIMENSION*2; i++) { 
00258             dst = pack8(dst, (char*)&rect->boundary[i]);
00259         }
00260     }
00261     return dst;
00262 }
00263 
00264 #ifdef UNICODE
00265 inline char* pack_str(char* dst, char_t const* src) { 
00266     char_t ch;
00267     do {
00268         ch = *src++;
00269         *dst++ = (char)(ch >> 8);
00270         *dst++ = (char)ch;
00271     } while (ch != '\0');
00272     return dst;
00273 }
00274 inline char* pack_str(char* dst, char_t const* src, int n) { 
00275     char_t ch;
00276     while (--n >= 0) { 
00277         ch = *src++;
00278         *dst++ = (char)(ch >> 8);
00279         *dst++ = (char)ch;
00280     }
00281     return dst;
00282 }
00283 #else
00284 inline char* pack_str(char* dst, char const* src) { 
00285     while ((*dst++ = *src++) != '\0');
00286     return dst;
00287 }
00288 inline char* pack_str(char* dst, char const* src, int n) { 
00289     while (--n >= 0) { 
00290         *dst++ = *src++;
00291     }
00292     return dst;
00293 }
00294 #endif
00295 
00296 inline int2 unpack2(char const* src) {
00297     nat1* s = (nat1*)src;
00298     return (s[0] << 8) + s[1];
00299 }
00300 
00301 inline char* unpack2(char* dst, char* src) {
00302     *(int2*)dst = unpack2(src);
00303     return src + 2;
00304 }
00305 
00306 inline void  unpack2(int2& val) {
00307 #if BYTE_ORDER != BIG_ENDIAN
00308 #ifdef USE_HTON_NTOH
00309     val = ntohs(val);
00310 #else
00311     val = unpack2((char*)&val);
00312 #endif
00313 #endif
00314 }
00315 
00316 
00317 inline int4  unpack4(char const* src) {
00318     nat1* s = (nat1*)src;
00319     return (((((s[0] << 8) + s[1]) << 8) + s[2]) << 8) + s[3];
00320 }
00321 
00322 inline char* unpack4(char* dst, char* src) {
00323     *(int4*)dst = unpack4(src);
00324     return src + 4;
00325 }
00326 
00327 inline void unpack4(int4& val) {
00328 #if BYTE_ORDER != BIG_ENDIAN
00329 #ifdef USE_HTON_NTOH
00330     val = ntohl(val);
00331 #else
00332     val = unpack4((char*)&val);
00333 #endif
00334 #endif
00335 }
00336 
00337 inline char* unpack8(char* dst, char* src) {
00338 #if BYTE_ORDER == BIG_ENDIAN
00339     *(int4*)dst = unpack4(src);
00340     *((int4*)dst+1) = unpack4(src+4);
00341 #else
00342     *(int4*)dst = unpack4(src+4);
00343     *((int4*)dst+1) = unpack4(src);
00344 #endif
00345     return src + 8;
00346 }
00347 
00348 inline db_int8 unpack8(char* src) {
00349     db_int8 val;
00350     unpack8((char*)&val, src);
00351     return val;
00352 }
00353 
00354 inline cli_oid_t unpack_oid(char* src)
00355 {
00356     cli_oid_t oid;
00357     if (sizeof(oid) == 4) {
00358         oid = unpack4(src);
00359     } else {
00360         unpack8((char*)&oid, src);
00361     }
00362     return oid;
00363 }
00364 
00365 inline char* unpack_rectangle(cli_rectangle_t* rect, char* src)
00366 {
00367     if (sizeof(cli_coord_t) == 4) { 
00368         for (int i = 0; i < CLI_RECTANGLE_DIMENSION*2; i++) { 
00369             src = unpack4((char*)&rect->boundary[i], src);
00370         }
00371     } else { 
00372         for (int i = 0; i < CLI_RECTANGLE_DIMENSION*2; i++) { 
00373             src = unpack8((char*)&rect->boundary[i], src);
00374         }
00375     }
00376     return src;
00377 }
00378 
00379 #ifdef UNICODE
00380 inline char* skip_str(char* p) {
00381     while (p[0] != 0 || p[1] != 0) {
00382         p += 2;
00383     }
00384     return p + 2;
00385 }
00386 inline char* unpack_str(char_t* dst, char* src) {
00387     char_t ch;
00388     do {
00389         ch = (src[0] << 8) | (src[1] & 0xFF);
00390         src += sizeof(char_t);
00391         *dst++ = ch;
00392     } while (ch != '\0');
00393     return src;
00394 }
00395 inline char* unpack_str(char_t* dst, char* src, int n) {
00396     char_t ch;
00397     while (--n >= 0) { 
00398         ch = (src[0] << 8) | (src[1] & 0xFF);
00399         src += sizeof(char_t);
00400         *dst++ = ch;
00401     } 
00402     return src;
00403 }
00404 inline char_t unpack_char(char const* p) { 
00405     return (p[0] << 8) | (p[1] & 0xFF);
00406 }
00407 #else
00408 inline char* skip_str(char* p) {
00409     while (*p++ != 0);
00410     return p;
00411 }
00412 inline char* unpack_str(char* dst, char* src) {
00413     while ((*dst++ = *src++) != '\0');
00414     return src;
00415 }
00416 inline char* unpack_str(char* dst, char* src, int n) {
00417     while (--n >= 0) {
00418         *dst++ = *src++;
00419     }
00420     return src;
00421 }
00422 inline char_t unpack_char(char const* p) {
00423     return *p;
00424 }
00425 #endif
00426 
00427 struct cli_request {
00428     int4 length;
00429     int4 cmd;
00430     int4 stmt_id;
00431 #ifdef SECURE_SERVER
00432     int4 sig;
00433 #endif
00434 
00435     void pack() {
00436 #ifdef SECURE_SERVER
00437         int i, s = length + cmd + stmt_id;
00438         char *p = (char *)&length + sizeof(cli_request);
00439         for (i = 0; i < length - sizeof(cli_request); i++, p++) {
00440             s += (*p << 7) + (*p << 3) + i;
00441         }
00442         sig = s;
00443 #endif
00444         pack4(length);
00445         pack4(cmd);
00446         pack4(stmt_id);
00447 #ifdef SECURE_SERVER
00448         pack4(sig);
00449 #endif
00450     }
00451 
00452     void unpack() {
00453         unpack4(length);
00454         unpack4(cmd);
00455         unpack4(stmt_id);
00456 #ifdef SECURE_SERVER
00457         unpack4(sig);
00458 #endif
00459     }
00460 };
00461 
00462 END_GIGABASE_NAMESPACE
00463 
00464 #endif

Generated on Thu Nov 24 23:14:29 2005 for GigaBASE by doxygen 1.3.5