← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to examples/sqlite_server.c

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/sqlite_server.c
4
4
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
5
5
 * All rights reserved.
6
6
 *
7
 
 * Use and distribution licensed under the BSD license.  See
8
 
 * the COPYING file in this directory for full text.
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are
 
9
 * met:
 
10
 *
 
11
 *     * Redistributions of source code must retain the above copyright
 
12
 * notice, this list of conditions and the following disclaimer.
 
13
 *
 
14
 *     * Redistributions in binary form must reproduce the above
 
15
 * copyright notice, this list of conditions and the following disclaimer
 
16
 * in the documentation and/or other materials provided with the
 
17
 * distribution.
 
18
 *
 
19
 *     * The names of its contributors may not be used to endorse or
 
20
 * promote products derived from this software without specific prior
 
21
 * written permission.
 
22
 *
 
23
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
24
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
25
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
26
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
27
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
28
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
29
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
30
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
31
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
32
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
33
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
34
 *
9
35
 */
10
36
 
 
37
 
11
38
#include <errno.h>
12
39
#include <stdio.h>
13
40
#include <stdlib.h>
66
93
  bool mysql= false;
67
94
  in_port_t port= 0;
68
95
  drizzle_return_t ret;
69
 
  sqlite_server server;
70
 
  drizzle_con_st con_listen;
 
96
  sqlite_server *server= (sqlite_server*)malloc(sizeof(sqlite_server));
 
97
  drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
71
98
 
72
 
  server.db= NULL;
73
 
  server.verbose= DRIZZLE_VERBOSE_NEVER;
 
99
  server->db= NULL;
 
100
  server->verbose= DRIZZLE_VERBOSE_NEVER;
74
101
 
75
102
  while((c = getopt(argc, argv, "c:h:mp:v")) != -1)
76
103
  {
93
120
      break;
94
121
 
95
122
    case 'v':
96
 
      server.verbose++;
 
123
      switch(server->verbose)
 
124
      {
 
125
      case DRIZZLE_VERBOSE_NEVER:
 
126
        server->verbose= DRIZZLE_VERBOSE_FATAL;
 
127
        break;
 
128
      case DRIZZLE_VERBOSE_FATAL:
 
129
        server->verbose= DRIZZLE_VERBOSE_ERROR;
 
130
        break;
 
131
      case DRIZZLE_VERBOSE_ERROR:
 
132
        server->verbose= DRIZZLE_VERBOSE_INFO;
 
133
        break;
 
134
      case DRIZZLE_VERBOSE_INFO:
 
135
        server->verbose= DRIZZLE_VERBOSE_DEBUG;
 
136
        break;
 
137
      case DRIZZLE_VERBOSE_DEBUG:
 
138
        server->verbose= DRIZZLE_VERBOSE_CRAZY;
 
139
        break;
 
140
      case DRIZZLE_VERBOSE_CRAZY:
 
141
      case DRIZZLE_VERBOSE_MAX:
 
142
        break;
 
143
      }
97
144
      break;
98
145
 
99
146
    default:
108
155
    return 1;
109
156
  }
110
157
 
111
 
  sqlite3_open(argv[optind], &(server.db));
112
 
  if (server.db == NULL)
 
158
  sqlite3_open(argv[optind], &(server->db));
 
159
  if (server->db == NULL)
113
160
  {
114
161
    printf("sqlite3_open: could not open sqlite3 db\n");
115
162
    return 1;
116
163
  }
117
164
 
118
 
  if (drizzle_create(&server.drizzle) == NULL)
 
165
  if (drizzle_create(&(server->drizzle)) == NULL)
119
166
  {
120
167
    printf("drizzle_create:NULL\n");
121
168
    return 1;
122
169
  }
123
170
 
124
 
  drizzle_add_options(&server.drizzle, DRIZZLE_FREE_OBJECTS);
125
 
  drizzle_set_verbose(&server.drizzle, server.verbose);
 
171
  drizzle_add_options(&(server->drizzle), DRIZZLE_FREE_OBJECTS);
 
172
  drizzle_set_verbose(&(server->drizzle), server->verbose);
126
173
 
127
 
  if (drizzle_con_create(&server.drizzle, &con_listen) == NULL)
 
174
  if (drizzle_con_create(&(server->drizzle), con_listen) == NULL)
128
175
  {
129
176
    printf("drizzle_con_create:NULL\n");
130
177
    return 1;
131
178
  }
132
179
 
133
 
  drizzle_con_add_options(&con_listen, DRIZZLE_CON_LISTEN);
134
 
  drizzle_con_set_tcp(&con_listen, host, port);
 
180
  drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
 
181
  drizzle_con_set_tcp(con_listen, host, port);
135
182
 
136
183
  if (mysql)
137
 
    drizzle_con_add_options(&con_listen, DRIZZLE_CON_MYSQL);
 
184
    drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
138
185
 
139
 
  if (drizzle_con_listen(&con_listen) != DRIZZLE_RETURN_OK)
 
186
  if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
140
187
  {
141
 
    printf("drizzle_con_listen:%s\n", drizzle_error(&server.drizzle));
 
188
    printf("drizzle_con_listen:%s\n", drizzle_error(&(server->drizzle)));
142
189
    return 1;
143
190
  }
144
191
 
145
192
  while (1)
146
193
  {
147
 
    (void)drizzle_con_accept(&server.drizzle, &server.con, &ret);
 
194
    (void)drizzle_con_accept(&(server->drizzle), &(server->con), &ret);
148
195
    if (ret != DRIZZLE_RETURN_OK)
149
196
    {
150
 
      printf("drizzle_con_accept:%s\n", drizzle_error(&server.drizzle));
 
197
      printf("drizzle_con_accept:%s\n", drizzle_error(&(server->drizzle)));
151
198
      return 1;
152
199
    }
153
200
 
154
 
    server_run(&server);
 
201
    server_run(server);
155
202
 
156
 
    drizzle_con_free(&server.con);
 
203
    drizzle_con_free(&(server->con));
157
204
 
158
205
    if (count > 0)
159
206
    {
164
211
    }
165
212
  }
166
213
 
167
 
  drizzle_con_free(&con_listen);
168
 
  drizzle_free(&server.drizzle);
169
 
  sqlite3_close(server.db);
 
214
  drizzle_con_free(con_listen);
 
215
  drizzle_free(&(server->drizzle));
 
216
  sqlite3_close(server->db);
 
217
  free(con_listen);
 
218
  free(server);
170
219
 
171
220
  return 0;
172
221
}
211
260
    if (data != NULL)
212
261
      free(data);
213
262
 
214
 
    data= drizzle_con_command_buffer(&(server->con), &command, &total, &ret);
 
263
    data= (uint8_t *)drizzle_con_command_buffer(&(server->con), &command, &total, &ret);
215
264
    if (ret == DRIZZLE_RETURN_LOST_CONNECTION ||
216
265
        (ret == DRIZZLE_RETURN_OK && command == DRIZZLE_COMMAND_QUIT))
217
266
    {
308
357
  sqlite_server *server= (sqlite_server *)data;
309
358
  drizzle_return_t ret;
310
359
  int x;
311
 
  size_t sizes[8192];
 
360
  size_t *sizes= (size_t*)malloc(sizeof(size_t)*8192);
312
361
 
313
362
  if (server->send_columns == true)
314
363
  {
375
424
 
376
425
  server->rows++;
377
426
 
 
427
  free(sizes);
 
428
 
378
429
  return 0;
379
430
}
380
431