int
clip_FREAD(ClipMachine * ClipMachineMemory)
{
#if 0
int ret, *err, bl;
int fh = _clip_parni(ClipMachineMemory, 1);
char *buf = _clip_parcl(ClipMachineMemory, 2, &bl);
int kol = _clip_parni(ClipMachineMemory, 3);
if (bl < kol)
kol = bl;
ret = read(fh, buf, kol);
err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
if (ret < 0)
*err = errno;
else
*err = 0;
#else
int *err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
int fd = _clip_parni(ClipMachineMemory, 1), lenbuf = 0;
char *buf = _clip_parcl(ClipMachineMemory, 2, &lenbuf);
long ret = -1, nb = _clip_parnl(ClipMachineMemory, 3);
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
_clip_retnl(ClipMachineMemory, -1);
if (cf == NULL)
{
*err = EBADF;
return 0;
}
if (lenbuf < nb)
nb = lenbuf;
if (nb > 0)
{
if (cf->file_of_C_FILE == NULL || (cf->stat_of_C_FILE & FS_BUFFERED) == 0)
ret = _clip_read(cf, buf, nb);
else
ret = fread(buf, 1, nb, cf->file_of_C_FILE);
}
else
ret = 0;
*err = ret < 0 ? errno : 0;
#endif
_clip_retnl(ClipMachineMemory, ret);
return 0;
}
int pg_createconn(ClipMachine* mp){
char* pghost = _clip_parc(mp,2);
char* pgport = _clip_parc(mp,3);
char* login = _clip_parc(mp,4);
char* pwd = _clip_parc(mp,5);
char* dbName = _clip_parc(mp,6);
char* pgtty = _clip_parc(mp,7);
char* pgoptions = _clip_parc(mp,8);
char* trpars = _clip_parc(mp,10);
PGconn* tmpconn;
PGresult* res;
PG_CONN* conn;
char str[256];
tmpconn = PQsetdbLogin(pghost,pgport,pgoptions,pgtty,dbName,login,pwd);
if(PQstatus(tmpconn)!=CONNECTION_OK){
_clip_trap_err(mp,0,0,0,subsys,ER_CONNECT,PQerrorMessage(tmpconn));
return -1;
}
conn = malloc(sizeof(PG_CONN));
memset(conn,0,sizeof(PG_CONN));
conn->conn = tmpconn;
conn->vtbl = &vtbl;
res = PQexec(tmpconn,"SET DATESTYLE='ISO'");
if(PQresultStatus(res) != PGRES_COMMAND_OK){
_clip_trap_err(mp,0,0,0,subsys,ER_BADSTATEMENT,
PQresultErrorMessage(res));
return -1;
}
if(!trpars)
trpars = _clip_fetch_item(mp, _clip_hashstr("PG_ISOLATION_LEVEL"));
if(!trpars)
trpars = _clip_fetch_item(mp, _clip_hashstr("SQL_ISOLATION_LEVEL"));
if(trpars){
snprintf(str,sizeof(str),"set session characteristics as transaction isolation level %s",trpars);
res = PQexec(tmpconn,str);
if(PQresultStatus(res) != PGRES_COMMAND_OK){
_clip_trap_err(mp,0,0,0,subsys,ER_BADSTATEMENT,
PQresultErrorMessage(res));
return -1;
}
}
PQsetNoticeProcessor(tmpconn, notice_processor, NULL);
return _clip_store_c_item(mp,(void*)conn,_C_ITEM_TYPE_SQL,destroy_pg_conn);
}
unsigned char *
_clip_atmupa(ClipMachine * ClipMachineMemory, unsigned char *sstr, int l1, unsigned char *str, int l2, int ignore, int count, int flag)
{
unsigned char *e1, *e2, *s, *beg, *end, *send;
int cset = (*(unsigned char *) _clip_fetch_item(ClipMachineMemory, HASH_csetatmupa)) == 't';
char *atlike = _clip_fetch_item(ClipMachineMemory, HASH_setatlike);
int atlike0, atlike1;
int sovp = 0;
atlike0 = atlike[0];
atlike1 = atlike[1];
end = str + l2 - l1 + 1;
beg = str + l2;
if (l1 == 0)
return beg;
send = sstr + l1;
if (ignore < 0)
ignore = 0;
for (e1 = str + ignore; e1 < end; e1++)
{
if (*e1 != *sstr)
continue;
for (s = sstr, e2 = e1; s < send && (*s == *e2 || (atlike0 && *s == atlike1)); s++, e2++);
if (s != send)
continue;
if (flag)
beg = e1;
if (!cset)
e1 = e2 - 1;
if (!flag)
{
if (count != 0 || (cset && count == 0))
beg = e2;
else
beg = e1;
}
sovp++;
if (count != 0 && sovp >= count)
break;
}
if ((count != 0 && sovp < count) || sovp == 0)
beg = str + l2;
return beg;
}
int
clip_CHMOD(ClipMachine * ClipMachineMemory)
{
int lp = 0, *err = NULL;
char buf[PATH_MAX];
char *fname = _clip_parc(ClipMachineMemory, 1);
_clip_retl(ClipMachineMemory, 1);
err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
*err = 0;
if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType)
lp = _clip_fileStrModeToNumMode(_clip_parc(ClipMachineMemory, 2));
if (_clip_parinfo(ClipMachineMemory, 2) == NUMERIC_type_of_ClipVarType)
lp = _clip_parni(ClipMachineMemory, 2);
if (fname == NULL || lp == 0)
{
_clip_retl(ClipMachineMemory, 0);
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHMOD");
}
_clip_translate_path(ClipMachineMemory, fname, buf, sizeof(buf));
if (chmod(buf, lp) == 0)
return 0;
_clip_retl(ClipMachineMemory, 0);
*err = errno;
return 0;
}
int
clip_CHARAND(ClipMachine * ClipMachineMemory)
{
int l1, l2;
unsigned char *ret, *e, *end, *e2, *end2;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (str == NULL || s == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARAND");
}
ret = malloc(l1 + 1);
memcpy(ret, str, l1);
ret[l1] = 0;
end2 = s + l2;
for (e = ret, end = ret + l1; e < end;)
for (e2 = s; e2 < end2 && e < end; e++, e2++)
*e = (*e & *e2);
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l1);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l1);
return 0;
}
int
clip_COM_INIT(ClipMachine * mp)
{
v24_port_t *gz;
int ret = -1, *err;
int fd = _clip_parni(mp, 1);
int baud = 9600, data = 8, stop = 1;
char *parity = "N";
if (fd < 1 || fd > 32)
return EG_ARG;
fd = keys[fd];
gz = (v24_port_t *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_COMPORT);
if (!gz)
return EG_ARG;
if (_clip_parinfo(mp, 2) == NUMERIC_t)
baud = _clip_parni(mp, 2);
if (_clip_parinfo(mp, 3) == CHARACTER_t)
parity = _clip_parc(mp, 3);
if (_clip_parinfo(mp, 4) == NUMERIC_t)
data = _clip_parni(mp, 4);
if (_clip_parinfo(mp, 5) == NUMERIC_t)
stop = _clip_parni(mp, 5);
err = _clip_fetch_item(mp, HASH_ferror);
ret = v24SetParameters(gz, baud_val(baud), data_val(data), parity_val(parity));
_clip_retl(mp, ret ? 0 : 1);
return 0;
}
int
clip_CHARSWAP(ClipMachine * ClipMachineMemory)
{
int l, i;
unsigned char *ret, ch;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (str == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHARSWAP");
}
ret = str;
ret = malloc(l + 1);
for (i = 0; i < l; i += 2)
{
if (i < l - 1)
{
ch = str[i];
ret[i] = str[i + 1];
ret[i + 1] = ch;
}
else
ret[i] = str[i];
}
ret[l] = 0;
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l);
return 0;
}
int
clip_GETSHARE(ClipMachine * ClipMachineMemory) /* Determines the file open (share) mode */
{
int *smode = _clip_fetch_item(ClipMachineMemory, CLIP_CA_SHARE_MODE);
_clip_retni(ClipMachineMemory, smode ? *smode : LOCK_RDONLY);
return 0;
}
int
clip_CURRDRIVE(ClipMachine * ClipMachineMemory)
{
char *s = _clip_fetch_item(ClipMachineMemory, CLIP_CUR_DRIVE);
_clip_retc(ClipMachineMemory, s ? s : "");
return 0;
}
int
ms_createconn(ClipMachine * mp)
{
char *host = _clip_parc(mp, 2);
char *portstr = _clip_parc(mp, 3);
char *user = _clip_parc(mp, 4);
char *passwd = _clip_parc(mp, 5);
char *db = _clip_parc(mp, 6);
char *socket = _clip_parc(mp, 7);
char *flagstr = _clip_parc(mp, 8);
char *trpars = _clip_parc(mp, 10);
unsigned int port = portstr ? atoi(portstr) : 0;
unsigned int flag = flagstr ? atoi(flagstr) : 0;
MS_CONN *conn;
MYSQL *tmpconn;
char str[256];
int status;
tmpconn = mysql_init(NULL);
tmpconn = mysql_real_connect(tmpconn, host, user, passwd, db, port, socket, flag);
if (!tmpconn)
{
_clip_trap_err(mp, 0, 0, 0, subsys, ER_CONNECT, er_connect);
return -1;
}
conn = calloc(1,sizeof(MS_CONN));
conn->conn = tmpconn;
conn->vtbl = &vtbl;
if(!trpars)
trpars = _clip_fetch_item(mp, _clip_hashstr("MS_ISOLATION_LEVEL"));
if(!trpars)
trpars = _clip_fetch_item(mp, _clip_hashstr("SQL_ISOLATION_LEVEL"));
if(trpars){
snprintf(str,sizeof(str),"set session transaction isolation level %s",trpars);
status = mysql_query(conn->conn,str);
if(status){
_clip_trap_err(mp,0,0,0,subsys,ER_BADSTATEMENT,mysql_error(conn->conn));
mysql_close(conn->conn);
return -1;
}
}
return _clip_store_c_item(mp, (void *) conn, _C_ITEM_TYPE_SQL, destroy_ms_conn);
}
int
clip_UDPSENDTO(ClipMachine *mp)
// UDPSENDTO( nCF, cIPaddr, nPort, cMsg, [nLen], [nTimeout] )
{
int fd = _clip_parni(mp, 1);
C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
char *ipaddr = _clip_parc(mp, 2);
int port = _clip_parni(mp,3), lenbuf;
char *msg = _clip_parcl(mp,4, &lenbuf);
long len = _clip_parnl(mp,5);
int timeout = _clip_parni(mp,6);
int ret = -1, *err = _clip_fetch_item(mp, HASH_ferror);
struct sockaddr_in sin;
struct timeval tv;
fd_set set;
if (cf == NULL || cf->type != FT_SOCKET)
*err = EBADF;
else
{
if (_clip_parinfo(mp, 5) != NUMERIC_t)
len = lenbuf;
if (len > lenbuf)
len = lenbuf;
if (_clip_parinfo(mp, 6) != NUMERIC_t)
timeout = cf->timeout;
if ( timeout >= 0 ) {
FD_ZERO(&set);
FD_SET(cf->fileno, &set);
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout % 1000) * 1000;
}
memset( (void *) &sin, 0, sizeof(sin) );
sin.sin_family = PF_INET;
sin.sin_addr.s_addr = inet_addr(ipaddr);
sin.sin_port = htons(port);
if ( timeout < 0 || select( cf->fileno+1, NULL, &set, NULL, &tv ) > 0 )
{
ret = sendto( cf->fileno, msg, len, 0, (struct sockaddr *) &sin, sizeof(sin) );
*err = ret == -1 ? errno : 0;
}
else
#ifdef OS_MINGW
*err = EAGAIN;
#else
*err = ETIMEDOUT;
#endif
}
_clip_retnl(mp, ret);
return 0;
}
int
clip_FSEEK(ClipMachine * ClipMachineMemory)
{
int fd = _clip_parni(ClipMachineMemory, 1);
long nb = _clip_parnl(ClipMachineMemory, 2);
int whence = SEEK_SET, w = _clip_parni(ClipMachineMemory, 3), *err, ret = -1;
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
*err = 0;
_clip_retnl(ClipMachineMemory, -1);
if (cf == NULL)
{
*err = EBADF;
return 0;
}
else if (cf->type_of_C_FILE == FT_FIFO || cf->type_of_C_FILE == FT_SOCKET)
{
*err = ESPIPE;
return 0;
}
switch (w)
{
case 0:
whence = SEEK_SET;
break;
case 1:
whence = SEEK_CUR;
break;
case 2:
whence = SEEK_END;
break;
}
if (cf->file_of_C_FILE == NULL || (cf->stat_of_C_FILE & FS_BUFFERED) == 0)
{
if ((ret = lseek(cf->fileno_of_C_FILE, nb, whence)) == -1)
*err = errno;
}
else
{
if ((ret = fseek(cf->file_of_C_FILE, nb, whence)) == -1)
*err = errno;
else
ret = ftell(cf->file_of_C_FILE);
}
_clip_retnl(ClipMachineMemory, ret);
return 0;
}
int
clip_QOUT(ClipMachine * ClipMachineMemory)
{
char *pEol = (char *) _clip_fetch_item(ClipMachineMemory, _clip_hashstr("PRINTER_EOL"));
if (pEol == NULL || *pEol == 0)
out_any(ClipMachineMemory, "\n", 1, _clip_colorSelect(ClipMachineMemory), DEV_DEVS);
else
out_any(ClipMachineMemory, pEol, strlen(pEol), _clip_colorSelect(ClipMachineMemory), DEV_DEVS);
clip_QQOUT(ClipMachineMemory);
sync_mp(ClipMachineMemory);
return 0;
}
int
clip_TCPGETPEERNAME(ClipMachine * ClipMachineMemory)
/* Get the address of the peer to which a socket is connected.
using : tcpGetPeerName( sock, @cIPadr ) -> 0 - OK | -1 == error
*/
{
int ret = -1, sln;
int *err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
int fd = _clip_parni(ClipMachineMemory, 1);
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
char ipaddr[INET_ADDRSTRLEN];
struct sockaddr_in sin;
_clip_retnl(ClipMachineMemory, -1);
if (cf == NULL || cf->type_of_C_FILE != FT_SOCKET)
{
*err = EBADF;
}
else
{
sln = sizeof(sin);
ret = getpeername(cf->fileno_of_C_FILE, (struct sockaddr *) &sin, (socklen_t *) (&sln));
*err = ret < 0 ? errno : 0;
if (ret >= 0)
{
#ifdef _WIN32
_clip_storc(ClipMachineMemory, inet_ntoa(*(struct in_addr *) ipaddr), 2, 0);
#else
if (inet_ntop(PF_INET, &sin.sin_addr.s_addr, ipaddr, INET_ADDRSTRLEN) == NULL)
ret = -1;
else
_clip_storc(ClipMachineMemory, ipaddr, 2, 0);
#endif
_clip_storni(ClipMachineMemory, ntohs(sin.sin_port), 3, 0);
}
else
_clip_storni(ClipMachineMemory, -1, 3, 0);
}
_clip_retnl(ClipMachineMemory, ret);
return 0;
}
/*
COM_OPEN(nPort|cDevice,[dontused],[dontused],[dontused],l_RTSCTS,l_XONXOFF,lDebug)
*/
int
clip_COM_OPEN(ClipMachine * mp)
{
int no = _clip_parni(mp, 1);
char *dev = _clip_parc(mp, 1);
char buf[V24_SZ_PORTNAME+1];
int ctsrts = _clip_parl(mp, 5);
int xonxoff = _clip_parl(mp, 6);
int dbg = _clip_parl(mp, 7);
v24_port_t *gz;
int *err, k;
if (!_clip_parinfo(mp, 5) && !!_clip_parinfo(mp, 5))
ctsrts = 1;
if (!dev && (no < 1 || no > 32))
return EG_ARG;
if (!dev)
{
v24PortName(no - 1, buf);
dev = buf;
}
gz = v24OpenPort(dev,
V24_STANDARD
| V24_LOCK
/*| V24_NO_DELAY*/
| (ctsrts ? V24_RTS_CTS : 0)
| (xonxoff ? V24_XON_XOFF : 0)
| V24_DROP_DTR
| (dbg ? V24_DEBUG_ON : 0)
);
if (!gz)
{
err = _clip_fetch_item(mp, HASH_ferror);
*err = errno;
_clip_retl(mp, 0);
return 0;
}
k = _clip_store_c_item(mp, gz, _C_ITEM_TYPE_COMPORT, destroy_com_port);
keys[no] = k;
_clip_retl(mp, 1);
return 0;
}
char *
_clip_curdir(ClipMachine * ClipMachineMemory, char *drv)
{
int i;
char *dir;
dir = _clip_fetch_item(ClipMachineMemory, _hash_cur_dir[drv[0] - 65]);
if (dir == NULL /* || *dir==0 */ )
return "";
for (i = 0; dir[i] != 0; i++)
if (dir[i] == '\\')
dir[i] = '/';
if (*dir == '/')
dir++;
return dir;
}
int
clip_SETATLIKE(ClipMachine * ClipMachineMemory)
{
char *atlike;
atlike = _clip_fetch_item(ClipMachineMemory, HASH_setatlike);
_clip_retni(ClipMachineMemory, atlike[0]);
if (_clip_parinfo(ClipMachineMemory, 1) == NUMERIC_type_of_ClipVarType)
atlike[0] = _clip_parni(ClipMachineMemory, 1);
if (_clip_parinfo(ClipMachineMemory, 1) == LOGICAL_type_of_ClipVarType)
atlike[0] = _clip_parl(ClipMachineMemory, 1);
if (_clip_parinfo(ClipMachineMemory, 2) == NUMERIC_type_of_ClipVarType)
atlike[1] = _clip_parni(ClipMachineMemory, 2);
if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType)
atlike[1] = *(_clip_parc(ClipMachineMemory, 2));
return 0;
}
int
clip_SETCLEARB(ClipMachine * ClipMachineMemory)
{
int ch = _clip_parni(ClipMachineMemory, 1);
char *s = _clip_parc(ClipMachineMemory, 1);
int *set = _clip_fetch_item(ClipMachineMemory, HASH_setclearb);
if (s != NULL)
ch = (*s);
ch = (ch % 0xff);
*((char *) set) = (char) ch;
_clip_retc(ClipMachineMemory, "");
return 0;
}
int
clip_UDPBROADCAST(ClipMachine *mp)
{
int fd = _clip_parni(mp, 1);
C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
int *err = _clip_fetch_item(mp, HASH_ferror), ret = -1, arg;
if (cf == NULL || cf->type != FT_SOCKET)
*err = EBADF;
else
{
arg = _clip_parl(mp,2);
ret = setsockopt(cf->fileno, SOL_SOCKET, SO_BROADCAST, (void *) &arg, sizeof(arg));
*err = ret == -1 ? errno : 0;
}
_clip_retni(mp, ret);
return 0;
}
int
clip_COM_READ(ClipMachine * mp)
{
v24_port_t *gz;
char *buf;
int *err = NULL, fd, nb = 0;
long ret = -1;
fd = _clip_parni(mp, 1);
nb = _clip_parni(mp, 2);
if (fd < 1 || fd > 32)
return EG_ARG;
fd = keys[fd];
gz = _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_COMPORT);
if (gz == NULL)
return EG_ARG;
if (!nb)
nb = 1024;
buf = (char *) malloc(nb);
ret = v24Read(gz, (unsigned char *)buf, nb);
if (ret < 0)
{
err = _clip_fetch_item(mp, HASH_ferror);
*err = errno;
ret = 0;
if (gz->Errno != V24_E_OK)
{
free(buf);
return EG_READ;
}
}
buf = (char *) realloc(buf, ret + 1);
buf[ret] = 0;
_clip_retcn_m(mp, buf, ret);
return 0;
}
int
clip_TCPREAD(ClipMachine *mp)
{
int lenbuf = 0, ret = -1;
int *err = _clip_fetch_item(mp, HASH_ferror);
int fd = _clip_parni(mp, 1);
char *buf = _clip_parcl(mp, 2, &lenbuf);
long len = _clip_parnl(mp,3);
int timeout = _clip_parni(mp,4), oldtout;
C_FILE *cf = _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
_clip_retnl(mp, -1);
if (cf == NULL || cf->type != FT_SOCKET)
{
*err = EBADF;
}
else
{
if (lenbuf < len)
len = lenbuf;
oldtout = cf->timeout;
if (_clip_parinfo(mp, 4) == NUMERIC_t)
cf->timeout = timeout;
if (len > 0)
{
if (cf->f == NULL || (cf->stat & FS_BUFFERED) == 0)
ret = _clip_read(cf, buf, len);
else
ret = fread(buf, 1, len, cf->f);
}
else
ret = 0;
cf->timeout = oldtout;
*err = ret < 0 ? errno : 0;
}
_clip_retnl(mp, ret);
return 0;
}
/*
* NUMDISKH() --> nNumber
*/
int
clip_NUMDISKH(ClipMachine * ClipMachineMemory) /* Determines the number of hard disks */
{
char hstr[3];
int i = 0, n = 0;
hstr[1] = ':';
hstr[2] = 0;
for (i = 'A'; i <= 'Z'; i++)
{
hstr[0] = i;
if (_clip_fetch_item(ClipMachineMemory, _clip_hashstr(hstr)) == NULL)
continue;
n++;
}
_clip_retni(ClipMachineMemory, n);
return 0;
}
int
clip_FTRUNC(ClipMachine * ClipMachineMemory)
{
int *err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
int fd = _clip_parni(ClipMachineMemory, 1), fno = -1;
long len = _clip_parnl(ClipMachineMemory, 2);
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
if (cf == NULL)
{
*err = EBADF;
_clip_retl(ClipMachineMemory, 0);
return 0;
}
if (cf->file_of_C_FILE == NULL || (cf->stat_of_C_FILE & FS_BUFFERED) == 0)
fno = cf->fileno_of_C_FILE;
else
fno = fileno(cf->file_of_C_FILE);
if (fno == -1)
{
*err = EBADF;
_clip_retl(ClipMachineMemory, 0);
return 0;
}
if (_clip_parinfo(ClipMachineMemory, 0) < 2)
len = lseek(fno, 0, SEEK_CUR);
//if ( len > 0 )
len = ftruncate(fno, len);
*err = len < 0 ? errno : 0;
_clip_retl(ClipMachineMemory, len >= 0);
return 0;
}
int
clip_JUSTRIGHT(ClipMachine * ClipMachineMemory)
{
int l1, l2, i;
unsigned char *e, *ret, *end, *cur;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l1);
int ch = _clip_parni(ClipMachineMemory, 2);
unsigned char *s = (unsigned char *) _clip_parcl(ClipMachineMemory, 2, &l2);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (s != NULL)
ch = *s;
if (ch == 0)
ch = ' ';
if (str == NULL || l1 == 0)
{
_clip_retc(ClipMachineMemory, "");
return 0;
}
ret = malloc(l1 + 1);
for (e = str + l1 - 1, end = str; e > end && *e == ch; e--);
i = str + l1 - e - 1;
end = str + l1 - i;
for (cur = ret; i > 0; i--, cur++)
*cur = ch;
for (e = str; e < end; e++, cur++)
*cur = *e;
ret[l1] = 0;
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l1);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l1);
return 0;
}
/*
COM_SEND(<nComPort>,<cString>) --> nLength
return length of UNSENDED data
*/
int
clip_COM_SEND(ClipMachine * mp)
{
v24_port_t *gz;
int len = 0, *err = NULL;
int fd = _clip_parni(mp, 1);
char *sptr = NULL, buf[2], *str = _clip_parcl(mp, 2, &len);
long ret = -1;
if (fd < 1 || fd > 32)
return EG_ARG;
fd = keys[fd];
gz = (v24_port_t *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_COMPORT);
if (_clip_parinfo(mp,2)== NUMERIC_t)
{
buf[0] = (char) _clip_parni(mp,2);
buf[1] = 0;
len = 1 ;
sptr = buf;
}
else
sptr = str;
if (gz == NULL || !sptr)
{
return EG_ARG;
}
ret = v24Write(gz, (unsigned char *)sptr, len);
err = _clip_fetch_item(mp, HASH_ferror);
*err = ret < 0 ? errno : 0;
_clip_retni(mp, (len - ret));
return 0;
}
int
clip_UDPSOCKET(ClipMachine *mp)
{
C_FILE *cf = NULL;
int arg = 0, sock = -1, ret = -1;
int *err = _clip_fetch_item(mp, HASH_ferror);
*err=0;
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
goto err;
#ifndef OS_MINGW
if ((arg = fcntl(sock, F_GETFL, 0)) == -1)
goto err;
fcntl(sock, F_SETFL, arg | O_NONBLOCK);
#endif
cf = calloc(1, sizeof(C_FILE));
cf->fileno = sock;
cf->f = NULL;
cf->type = FT_SOCKET;
cf->pid = -1;
cf->timeout = 60000;
cf->stat = 0; /* see FS_* flags */
ret = _clip_store_c_item(mp, cf, _C_ITEM_TYPE_FILE, destroy_c_file);
err:
if (ret == -1)
{
if ( *err != 0 )
*err = errno;
if (sock != -1)
close(sock);
}
_clip_retni(mp, ret);
return 0;
}
int
clip_REPLLEFT(ClipMachine * ClipMachineMemory)
{
int l;
unsigned char *ret, *e, *end;
unsigned char *str = (unsigned char *) _clip_parcl(ClipMachineMemory, 1, &l);
unsigned char *s1 = (unsigned char *) _clip_parc(ClipMachineMemory, 2);
int ch1 = _clip_parni(ClipMachineMemory, 2);
unsigned char *s2 = (unsigned char *) _clip_parc(ClipMachineMemory, 3);
int ch2 = _clip_parni(ClipMachineMemory, 3);
int rset = (*(char *) (_clip_fetch_item(ClipMachineMemory, HASH_csetref)) == 't');
if (str == NULL || s1 == NULL)
{
_clip_retc(ClipMachineMemory, "");
return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "REPLLEFT");
}
ch1 = s1 == NULL ? ch1 : *s1;
ch1 = ch1 == 0 ? ' ' : ch1;
ch2 = s2 == NULL ? ch2 : *s2;
ch2 = ch2 == 0 ? ' ' : ch2;
ret = malloc(l + 1);
memcpy(ret, str, l);
for (e = ret, end = ret + l; e < end && (*e == ch2); e++)
*e = ch1;
if (rset && _clip_par_isref(ClipMachineMemory, 1))
_clip_par_assign_str(ClipMachineMemory, 1, (char *) ret, l);
_clip_retcn_m(ClipMachineMemory, (char *) ret, l);
return 0;
}
int
clip___FILELOCK(ClipMachine * ClipMachineMemory)
{
int *err = _clip_fetch_item(ClipMachineMemory, HASH_ferror);
int fd = _clip_parni(ClipMachineMemory, 1);
C_FILE *cf = _clip_fetch_c_item(ClipMachineMemory, fd, _C_ITEM_TYPE_FILE);
_clip_retl(ClipMachineMemory, 0);
*err = 0;
if (cf == NULL)
{
*err = EBADF;
return 0;
}
if (_clip_setlock(ClipMachineMemory, cf->hash_of_C_FILE, cf->fileno_of_C_FILE, 1000000000 + 1, CLIP_LOCK_WRITE | CLIP_LOCK_FLOCK | CLIP_LOCK_HILEVEL))
*err = ENOLCK;
else
_clip_retl(ClipMachineMemory, 1);
return 0;
}
int
clip_UDPBIND(ClipMachine *mp)
{
int fd = _clip_parni(mp, 1);
C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
char *ipaddr = _clip_parc(mp, 2);
int port = _clip_parni(mp,3);
int ret = -1, *err = _clip_fetch_item(mp, HASH_ferror);
struct sockaddr_in sin;
if (cf == NULL || cf->type != FT_SOCKET)
*err = EBADF;
else
{
memset( (void *) &sin, 0, sizeof(sin) );
sin.sin_family = PF_INET;
sin.sin_addr.s_addr = inet_addr(ipaddr);
sin.sin_port = htons(port);
ret = bind( cf->fileno, (struct sockaddr *) &sin, sizeof(sin) );
*err = ret == -1 ? errno : 0;
}
_clip_retni(mp, ret);
return 0;
}
static int
_clip_sockclose(ClipMachine *mp)
{
int fd = _clip_parni(mp, 1);
C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE);
int ret = -1, *err = _clip_fetch_item(mp, HASH_ferror);
fd_set rfds;
struct timeval tv;
int arg;
if (cf == NULL || cf->type != FT_SOCKET)
{
*err = EBADF;
}
arg = fcntl(cf->fileno, F_GETFL, 0);
if(!(arg & O_NONBLOCK))
{
FD_ZERO(&rfds);
FD_SET(cf->fileno,&rfds);
tv.tv_sec = 1; //timeout / 1000;
tv.tv_usec = 100; //(timeout % 1000) * 1000;
select(cf->fileno+1,&rfds,NULL,NULL,&tv);
}
if (_clip_destroy_c_item(mp, fd, _C_ITEM_TYPE_FILE))
{
*err = ret = 0;
}
else
{
*err = errno;
}
/* _clip_retni(mp, ret); TODO? What type of value should return */
_clip_retl(mp, (ret == 0));
return 0;
}
