258 lines
8.8 KiB
C
258 lines
8.8 KiB
C
/****************************************************************
|
|
* *
|
|
* Copyright 2001, 2009 Fidelity Information Services, Inc *
|
|
* *
|
|
* This source code contains the intellectual property *
|
|
* of its copyright holder(s), and is made available *
|
|
* under a license. If you do not know the terms of *
|
|
* the license, please stop and do not read further. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
/* iosocket_write.c */
|
|
|
|
#include "mdef.h"
|
|
|
|
#include <errno.h>
|
|
#include "gtm_socket.h"
|
|
#include "gtm_inet.h"
|
|
#include "gtm_stdio.h"
|
|
#include "gtm_string.h"
|
|
|
|
#include "io.h"
|
|
#include "iotcpdef.h"
|
|
#include "iotcproutine.h"
|
|
#include "gt_timer.h"
|
|
#include "iosocketdef.h"
|
|
#include "dollarx.h"
|
|
#include "gtm_conv.h"
|
|
#include "gtm_utf8.h"
|
|
#include "stringpool.h"
|
|
#include "send_msg.h"
|
|
#include "error.h"
|
|
|
|
GBLREF io_pair io_curr_device;
|
|
#ifdef UNIX
|
|
GBLREF io_pair io_std_device;
|
|
GBLREF bool prin_out_dev_failure;
|
|
#endif
|
|
|
|
GBLREF tcp_library_struct tcp_routines;
|
|
GBLREF mstr chset_names[];
|
|
GBLREF UConverter *chset_desc[];
|
|
GBLREF spdesc stringpool;
|
|
|
|
void iosocket_write(mstr *v)
|
|
{
|
|
iosocket_write_real(v, TRUE);
|
|
}
|
|
|
|
void iosocket_write_real(mstr *v, boolean_t convert_output)
|
|
{
|
|
io_desc *iod;
|
|
mstr tempv;
|
|
char *out, *c_ptr, *c_top;
|
|
int in_b_len, b_len, status, new_len, c_len, mb_len;
|
|
int flags;
|
|
d_socket_struct *dsocketptr;
|
|
socket_struct *socketptr;
|
|
|
|
error_def(ERR_SOCKWRITE);
|
|
error_def(ERR_TEXT);
|
|
error_def(ERR_CURRSOCKOFR);
|
|
error_def(ERR_ZFF2MANY);
|
|
error_def(ERR_DELIMSIZNA);
|
|
error_def(ERR_ZINTRECURSEIO);
|
|
UNIX_ONLY(error_def(ERR_NOPRINCIO);)
|
|
|
|
SOCKET_DEBUG2(PRINTF("socwrite: ************************** Top of iosocket_write\n"); DEBUGSOCKFLUSH);
|
|
iod = io_curr_device.out;
|
|
assert(gtmsocket == iod->type);
|
|
dsocketptr = (d_socket_struct *)iod->dev_sp;
|
|
socketptr = dsocketptr->socket[dsocketptr->current_socket];
|
|
if (dsocketptr->n_socket <= dsocketptr->current_socket)
|
|
{
|
|
rts_error(VARLSTCNT(4) ERR_CURRSOCKOFR, 2, dsocketptr->current_socket, dsocketptr->n_socket);
|
|
return;
|
|
}
|
|
if (dsocketptr->mupintr)
|
|
rts_error(VARLSTCNT(1) ERR_ZINTRECURSEIO);
|
|
#ifdef MSG_NOSIGNAL
|
|
flags = MSG_NOSIGNAL; /* return EPIPE instead of SIGPIPE */
|
|
#else
|
|
flags = 0;
|
|
#endif
|
|
socketptr->lastop = TCP_WRITE;
|
|
if (socketptr->first_write)
|
|
{ /* First WRITE, do following
|
|
1. Transition to UTF16BE if ochset is UTF16 and WRITE a BOM
|
|
2. Convert ZFF into ochset format so we don't need to convert every time ZFF is output
|
|
3. Convert DELIMITER 0 to OCHSET format to avoid repeated conversions of DELIM0 on output
|
|
*/
|
|
if (CHSET_UTF16 == iod->ochset)
|
|
{
|
|
SOCKET_DEBUG2(PRINTF("socwrite: First write UTF16 -- writing BOM\n"); DEBUGSOCKFLUSH);
|
|
iod->ochset = CHSET_UTF16BE; /* per Unicode standard, assume big endian when endian
|
|
format is unspecified */
|
|
get_chset_desc(&chset_names[iod->ochset]);
|
|
DOTCPSEND(socketptr->sd, UTF16BE_BOM, UTF16BE_BOM_LEN, flags, status);
|
|
SOCKET_DEBUG2(PRINTF("socwrite: TCP send of BOM-BE with rc %d\n", status); DEBUGSOCKFLUSH);
|
|
if (0 != status)
|
|
{
|
|
SOCKERROR(iod, dsocketptr, socketptr, ERR_SOCKWRITE, status);
|
|
return;
|
|
}
|
|
#ifdef UNIX
|
|
else if (iod == io_std_device.out)
|
|
prin_out_dev_failure = FALSE;
|
|
#endif
|
|
}
|
|
if (CHSET_UTF16BE == iod->ochset || CHSET_UTF16LE == iod->ochset) /* need conversion of ZFF and DELIM0 */
|
|
{
|
|
if (0 < socketptr->zff.len)
|
|
{
|
|
new_len = gtm_conv(chset_desc[CHSET_UTF8], chset_desc[iod->ochset], &socketptr->zff, NULL,
|
|
NULL);
|
|
if (MAX_ZFF_LEN < new_len)
|
|
rts_error(VARLSTCNT(4) ERR_ZFF2MANY, 2, new_len, MAX_ZFF_LEN);
|
|
if (NULL != socketptr->zff.addr) /* we rely on newsocket.zff.addr being set to NULL
|
|
in iosocket_create() */
|
|
socketptr->zff.addr = (char *)malloc(MAX_ZFF_LEN);
|
|
socketptr->zff.len = new_len;
|
|
UNICODE_ONLY(socketptr->zff.char_len = 0); /* don't care */
|
|
memcpy(socketptr->zff.addr, stringpool.free, new_len);
|
|
}
|
|
|
|
if (0 < socketptr->n_delimiter)
|
|
{
|
|
new_len = gtm_conv(chset_desc[CHSET_UTF8], chset_desc[iod->ochset],
|
|
&socketptr->delimiter[0], NULL, NULL);
|
|
if (MAX_DELIM_LEN < new_len)
|
|
{
|
|
rts_error(VARLSTCNT(1) ERR_DELIMSIZNA);
|
|
return;
|
|
}
|
|
socketptr->odelimiter0.len = new_len;
|
|
UNICODE_ONLY(socketptr->odelimiter0.char_len = socketptr->delimiter[0].char_len);
|
|
socketptr->odelimiter0.addr = malloc(new_len);
|
|
memcpy(socketptr->odelimiter0.addr, stringpool.free, new_len);
|
|
}
|
|
}
|
|
socketptr->first_write = FALSE;
|
|
}
|
|
memcpy(dsocketptr->dollar_device, "0", SIZEOF("0"));
|
|
if (CHSET_M != iod->ochset)
|
|
{ /* For ochset == UTF-8, validate the output,
|
|
* For ochset == UTF-16[B|L]E, convert the output (and validate during conversion)
|
|
*/
|
|
if (CHSET_UTF8 == iod->ochset)
|
|
{
|
|
UTF8_LEN_STRICT(v->addr, v->len); /* triggers badchar error for invalid sequence */
|
|
tempv = *v;
|
|
} else
|
|
{
|
|
assert(CHSET_UTF16BE == iod->ochset || CHSET_UTF16LE == iod->ochset);
|
|
/* Certain types of writes (calls from iosocket_wteol or _wtff) already have their output
|
|
converted. Converting again just wrecks it so avoid that when necessary.
|
|
*/
|
|
if (convert_output)
|
|
{
|
|
new_len = gtm_conv(chset_desc[CHSET_UTF8], chset_desc[iod->ochset], v, NULL, NULL);
|
|
tempv.addr = (char *)stringpool.free;
|
|
tempv.len = new_len;
|
|
/* Since there is no dependence on string pool between now and when we send the data,
|
|
we won't bother "protecting" the stringpool value. This space can be used again
|
|
by whomever needs it without us forcing a garbage collection due to IO reformat.
|
|
*/
|
|
/* stringpool.free += new_len; */
|
|
} else
|
|
tempv = *v;
|
|
}
|
|
} else
|
|
tempv = *v;
|
|
if (0 != (in_b_len = tempv.len))
|
|
{
|
|
SOCKET_DEBUG2(PRINTF("socwrite: starting output loop (%d bytes) - iodwidth: %d wrap: %d\n",
|
|
in_b_len, iod->width, iod->wrap); DEBUGSOCKFLUSH);
|
|
for (out = tempv.addr; ; out += b_len)
|
|
{
|
|
SOCKET_DEBUG2(PRINTF("socwrite: ---------> Top of write loop $x: %d $y: %d in_b_len: %d\n",
|
|
iod->dollar.x, iod->dollar.y, in_b_len); DEBUGSOCKFLUSH);
|
|
if (!iod->wrap)
|
|
b_len = in_b_len;
|
|
else
|
|
{
|
|
if ((iod->dollar.x >= iod->width) && (START == iod->esc_state))
|
|
{
|
|
/* Should this really be iosocket_Wteol() (for FILTER)? IF we call iosocket_wteol(),
|
|
* there will be recursion iosocket_Write -> iosocket_Wteol ->iosocket_Write */
|
|
if (0 < socketptr->n_delimiter)
|
|
{
|
|
DOTCPSEND(socketptr->sd, socketptr->odelimiter0.addr, socketptr->odelimiter0.len,
|
|
(socketptr->urgent ? MSG_OOB : 0) | flags, status);
|
|
SOCKET_DEBUG2(PRINTF("socwrite: TCP send of %d byte delimiter with rc %d\n",
|
|
socketptr->odelimiter0.len, status); DEBUGSOCKFLUSH);
|
|
if (0 != status)
|
|
{
|
|
SOCKERROR(iod, dsocketptr, socketptr, ERR_SOCKWRITE, status);
|
|
return;
|
|
}
|
|
#ifdef UNIX
|
|
else if (iod == io_std_device.out)
|
|
prin_out_dev_failure = FALSE;
|
|
#endif
|
|
}
|
|
iod->dollar.y++;
|
|
iod->dollar.x = 0;
|
|
SOCKET_DEBUG2(PRINTF("socwrite: $x > width - wrote delimiter: %d $x: %d $y: %d\n",
|
|
(0 < socketptr->n_delimiter), iod->dollar.x, iod->dollar.y);
|
|
DEBUGSOCKFLUSH);
|
|
}
|
|
if ((START != iod->esc_state) || ((int)(iod->dollar.x + in_b_len) <= (int)iod->width))
|
|
{ /* enough room even in the worst case, i.e., if width - dollar.x can accommodate in_b_len chars,
|
|
* it certainly can accommodate in_b_len bytes */
|
|
b_len = in_b_len;
|
|
} else
|
|
{
|
|
c_len = iod->width - iod->dollar.x;
|
|
for (c_ptr = out, c_top = out + in_b_len, b_len = 0;
|
|
(c_ptr < c_top) && c_len--;
|
|
b_len += mb_len, c_ptr += mb_len)
|
|
{
|
|
mb_len = (CHSET_M == iod->ochset) ? 0 :
|
|
(CHSET_UTF8 == iod->ochset) ? UTF8_MBFOLLOW(c_ptr) :
|
|
(CHSET_UTF16BE == iod->ochset) ? UTF16BE_MBFOLLOW(c_ptr, c_top) :
|
|
UTF16LE_MBFOLLOW(c_ptr, c_top);
|
|
assert(-1 != mb_len);
|
|
mb_len++;
|
|
}
|
|
SOCKET_DEBUG2(PRINTF("socwrite: computing string length in chars: in_b_len: %d"
|
|
" mb_len: %d\n", in_b_len, mb_len); DEBUGSOCKFLUSH);
|
|
}
|
|
}
|
|
assert(0 != b_len);
|
|
DOTCPSEND(socketptr->sd, out, b_len, (socketptr->urgent ? MSG_OOB : 0) | flags, status);
|
|
SOCKET_DEBUG2(PRINTF("socwrite: TCP data send of %d bytes with rc %d\n", b_len, status); DEBUGSOCKFLUSH);
|
|
if (0 != status)
|
|
{
|
|
SOCKERROR(iod, dsocketptr, socketptr, ERR_SOCKWRITE, status);
|
|
return;
|
|
}
|
|
#ifdef UNIX
|
|
else if (iod == io_std_device.out)
|
|
prin_out_dev_failure = FALSE;
|
|
#endif
|
|
dollarx(iod, (uchar_ptr_t)out, (uchar_ptr_t)out + b_len);
|
|
SOCKET_DEBUG2(PRINTF("socwrite: $x/$y updated by dollarx(): $x: %d $y: %d filter: %d escape: %d\n",
|
|
iod->dollar.x, iod->dollar.y, iod->write_filter, iod->esc_state);
|
|
DEBUGSOCKFLUSH);
|
|
in_b_len -= b_len;
|
|
if (0 >= in_b_len)
|
|
break;
|
|
}
|
|
iod->dollar.za = 0;
|
|
}
|
|
SOCKET_DEBUG2(PRINTF("socwrite: <--------- Leaving iosocket_write\n"); DEBUGSOCKFLUSH);
|
|
return;
|
|
}
|