← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to vio/vio.c

Put errmsg.c in sql-common since it can be built only once and used twice.
Put client.c and net_serv.c in libmysql so that we can only have one
link_sources section. 
Got rid of just about all copying and other weirdness, other than some stuff
in client and client.c/net_serv.c, which need to be reworked.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vio/vio.c
27
27
 */
28
28
 
29
29
static void vio_init(Vio* vio, enum enum_vio_type type,
30
 
                     int sd, uint32_t flags)
 
30
                     my_socket sd, HANDLE hPipe, uint flags)
31
31
{
 
32
  DBUG_ENTER("vio_init");
 
33
  DBUG_PRINT("enter", ("type: %d  sd: %d  flags: %d", type, sd, flags));
 
34
 
32
35
#ifndef HAVE_VIO_READ_BUFF
33
36
  flags&= ~VIO_BUFFERED_READ;
34
37
#endif
35
 
  memset(vio, 0, sizeof(*vio));
 
38
  bzero((char*) vio, sizeof(*vio));
36
39
  vio->type     = type;
37
40
  vio->sd       = sd;
 
41
  vio->hPipe    = hPipe;
 
42
  vio->localhost= flags & VIO_LOCALHOST;
38
43
  if ((flags & VIO_BUFFERED_READ) &&
39
44
      !(vio->read_buffer= (char*)my_malloc(VIO_READ_BUFFER_SIZE, MYF(MY_WME))))
40
45
    flags&= ~VIO_BUFFERED_READ;
 
46
#ifdef __WIN__ 
 
47
  if (type == VIO_TYPE_NAMEDPIPE)
 
48
  {
 
49
    vio->viodelete      =vio_delete;
 
50
    vio->vioerrno       =vio_errno;
 
51
    vio->read           =vio_read_pipe;
 
52
    vio->write          =vio_write_pipe;
 
53
    vio->fastsend       =vio_fastsend;
 
54
    vio->viokeepalive   =vio_keepalive;
 
55
    vio->should_retry   =vio_should_retry;
 
56
    vio->was_interrupted=vio_was_interrupted;
 
57
    vio->vioclose       =vio_close_pipe;
 
58
    vio->peer_addr      =vio_peer_addr;
 
59
    vio->vioblocking    =vio_blocking;
 
60
    vio->is_blocking    =vio_is_blocking;
 
61
    vio->timeout        =vio_ignore_timeout;
 
62
  }
 
63
  else                                  /* default is VIO_TYPE_TCPIP */
 
64
#endif
 
65
#ifdef HAVE_SMEM 
 
66
  if (type == VIO_TYPE_SHARED_MEMORY)
 
67
  {
 
68
    vio->viodelete      =vio_delete;
 
69
    vio->vioerrno       =vio_errno;
 
70
    vio->read           =vio_read_shared_memory;
 
71
    vio->write          =vio_write_shared_memory;
 
72
    vio->fastsend       =vio_fastsend;
 
73
    vio->viokeepalive   =vio_keepalive;
 
74
    vio->should_retry   =vio_should_retry;
 
75
    vio->was_interrupted=vio_was_interrupted;
 
76
    vio->vioclose       =vio_close_shared_memory;
 
77
    vio->peer_addr      =vio_peer_addr;
 
78
    vio->vioblocking    =vio_blocking;
 
79
    vio->is_blocking    =vio_is_blocking;
 
80
    vio->timeout        =vio_ignore_timeout;
 
81
  }
 
82
  else
 
83
#endif   
 
84
#ifdef HAVE_OPENSSL 
 
85
  if (type == VIO_TYPE_SSL)
 
86
  {
 
87
    vio->viodelete      =vio_ssl_delete;
 
88
    vio->vioerrno       =vio_errno;
 
89
    vio->read           =vio_ssl_read;
 
90
    vio->write          =vio_ssl_write;
 
91
    vio->fastsend       =vio_fastsend;
 
92
    vio->viokeepalive   =vio_keepalive;
 
93
    vio->should_retry   =vio_should_retry;
 
94
    vio->was_interrupted=vio_was_interrupted;
 
95
    vio->vioclose       =vio_ssl_close;
 
96
    vio->peer_addr      =vio_peer_addr;
 
97
    vio->vioblocking    =vio_ssl_blocking;
 
98
    vio->is_blocking    =vio_is_blocking;
 
99
    vio->timeout        =vio_timeout;
 
100
  }
 
101
  else                                  /* default is VIO_TYPE_TCPIP */
 
102
#endif /* HAVE_OPENSSL */
41
103
  {
42
104
    vio->viodelete      =vio_delete;
43
105
    vio->vioerrno       =vio_errno;
53
115
    vio->is_blocking    =vio_is_blocking;
54
116
    vio->timeout        =vio_timeout;
55
117
  }
 
118
  DBUG_VOID_RETURN;
56
119
}
57
120
 
58
121
 
59
122
/* Reset initialized VIO to use with another transport type */
60
123
 
61
124
void vio_reset(Vio* vio, enum enum_vio_type type,
62
 
               int sd, uint32_t flags)
 
125
               my_socket sd, HANDLE hPipe, uint flags)
63
126
{
64
 
  free(vio->read_buffer);
65
 
  vio_init(vio, type, sd, flags);
 
127
  my_free(vio->read_buffer, MYF(MY_ALLOW_ZERO_PTR));
 
128
  vio_init(vio, type, sd, hPipe, flags);
66
129
}
67
130
 
68
131
 
69
132
/* Open the socket or TCP/IP connection and read the fnctl() status */
70
133
 
71
 
Vio *vio_new(int sd, enum enum_vio_type type, uint32_t flags)
 
134
Vio *vio_new(my_socket sd, enum enum_vio_type type, uint flags)
72
135
{
73
136
  Vio *vio;
74
 
 
 
137
  DBUG_ENTER("vio_new");
 
138
  DBUG_PRINT("enter", ("sd: %d", sd));
75
139
  if ((vio = (Vio*) my_malloc(sizeof(*vio),MYF(MY_WME))))
76
140
  {
77
 
    vio_init(vio, type, sd, flags);
78
 
    sprintf(vio->desc, "TCP/IP (%d)", vio->sd);
 
141
    vio_init(vio, type, sd, 0, flags);
 
142
    sprintf(vio->desc,
 
143
            (vio->type == VIO_TYPE_SOCKET ? "socket (%d)" : "TCP/IP (%d)"),
 
144
            vio->sd);
 
145
#if !defined(__WIN__)
 
146
#if !defined(NO_FCNTL_NONBLOCK)
79
147
    /*
80
148
      We call fcntl() to set the flags and then immediately read them back
81
149
      to make sure that we and the system are in agreement on the state of
88
156
    */
89
157
    fcntl(sd, F_SETFL, 0);
90
158
    vio->fcntl_mode= fcntl(sd, F_GETFL);
91
 
  }
92
 
  return vio;
93
 
}
 
159
#elif defined(HAVE_SYS_IOCTL_H)                 /* hpux */
 
160
    /* Non blocking sockets doesn't work good on HPUX 11.0 */
 
161
    (void) ioctl(sd,FIOSNBIO,0);
 
162
    vio->fcntl_mode &= ~O_NONBLOCK;
 
163
#endif
 
164
#else /* !defined(__WIN__) */
 
165
    {
 
166
      /* set to blocking mode by default */
 
167
      ulong arg=0, r;
 
168
      r = ioctlsocket(sd,FIONBIO,(void*) &arg);
 
169
      vio->fcntl_mode &= ~O_NONBLOCK;
 
170
    }
 
171
#endif
 
172
  }
 
173
  DBUG_RETURN(vio);
 
174
}
 
175
 
 
176
 
 
177
#ifdef __WIN__
 
178
 
 
179
Vio *vio_new_win32pipe(HANDLE hPipe)
 
180
{
 
181
  Vio *vio;
 
182
  DBUG_ENTER("vio_new_handle");
 
183
  if ((vio = (Vio*) my_malloc(sizeof(Vio),MYF(MY_WME))))
 
184
  {
 
185
    vio_init(vio, VIO_TYPE_NAMEDPIPE, 0, hPipe, VIO_LOCALHOST);
 
186
    strmov(vio->desc, "named pipe");
 
187
  }
 
188
  DBUG_RETURN(vio);
 
189
}
 
190
 
 
191
#ifdef HAVE_SMEM
 
192
Vio *vio_new_win32shared_memory(NET *net,HANDLE handle_file_map, HANDLE handle_map,
 
193
                                HANDLE event_server_wrote, HANDLE event_server_read,
 
194
                                HANDLE event_client_wrote, HANDLE event_client_read,
 
195
                                HANDLE event_conn_closed)
 
196
{
 
197
  Vio *vio;
 
198
  DBUG_ENTER("vio_new_win32shared_memory");
 
199
  if ((vio = (Vio*) my_malloc(sizeof(Vio),MYF(MY_WME))))
 
200
  {
 
201
    vio_init(vio, VIO_TYPE_SHARED_MEMORY, 0, 0, VIO_LOCALHOST);
 
202
    vio->handle_file_map= handle_file_map;
 
203
    vio->handle_map= handle_map;
 
204
    vio->event_server_wrote= event_server_wrote;
 
205
    vio->event_server_read= event_server_read;
 
206
    vio->event_client_wrote= event_client_wrote;
 
207
    vio->event_client_read= event_client_read;
 
208
    vio->event_conn_closed= event_conn_closed;
 
209
    vio->shared_memory_remain= 0;
 
210
    vio->shared_memory_pos= handle_map;
 
211
    vio->net= net;
 
212
    strmov(vio->desc, "shared memory");
 
213
  }
 
214
  DBUG_RETURN(vio);
 
215
}
 
216
#endif
 
217
#endif
94
218
 
95
219
 
96
220
void vio_delete(Vio* vio)
100
224
 
101
225
  if (vio->type != VIO_CLOSED)
102
226
    vio->vioclose(vio);
103
 
  free((unsigned char*) vio->read_buffer);
104
 
  free((unsigned char*) vio);
 
227
  my_free((uchar*) vio->read_buffer, MYF(MY_ALLOW_ZERO_PTR));
 
228
  my_free((uchar*) vio,MYF(0));
105
229
}
106
230
 
107
231
 
112
236
*/
113
237
void vio_end(void)
114
238
{
 
239
#ifdef HAVE_YASSL
 
240
  yaSSL_CleanUp();
 
241
#endif
115
242
}