mars_nwe
/
mars-dosutils
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
mars-dosutils/netcall.c

419 lines
9.3 KiB
C
Executable File
Raw Permalink Blame History

/* netcall.c: 05-Apr-96 */
/****************************************************************
* (C)opyright (C) 1993,1996 Martin Stover, Marburg, Germany *
****************************************************************/
#include "net.h"
int neterrno=0;
int ipx_init(void)
{
static int ipx_is_init=0;
static int ipx_is_ok =0;
if (!ipx_is_init) {
ipx_is_init++;
ipx_is_ok = IPXinit();
}
return(ipx_is_ok);
}
static void *get_shell_ptr(uint16 func)
{
if (ipx_init()) {
void *p = NULL;
REGS regs;
SREGS sregs;
regs.x.ax = func;
if (!(intdosx(&regs, &regs, &sregs) & 0xff))
p = MK_FP(sregs.es, regs.x.si);
return(p);
} else return(NULL);
}
int detach(int servernmbr)
{
REGS regsin, regsout;
regsin.x.ax = 0xf101;
regsin.x.dx = servernmbr;
return(intdos(&regsin, &regsout) & 0xff);
}
int logout(void)
{
REGS regsin, regsout;
regsin.x.ax = 0xd700;
return(intdos(&regsin, &regsout) & 0xff);
}
int redir_device_drive(int devicetyp, uint8 *devname, uint8 *remotename)
/* if devicetyp == -1, the redir is canceled */
/* devicetyp 3 = printer */
/* devicetyp 4 = disk drive */
{
REGS regs;
SREGS sregs;
int result;
uint8 buff1[16];
uint8 buff2[128];
uint8 *ldevname = buff1;
uint8 *lremotename = buff2;
strncpy(ldevname, devname, 16);
regs.x.ax = (devicetyp == -1) ? 0x5f04 : 0x5f03;
regs.h.bl = (uint8)devicetyp;
regs.x.cx = 0x574e; /* user sign 'NW' */
sregs.ds = FP_SEG(ldevname);
regs.x.si = FP_OFF(ldevname);
if (devicetyp > -1) {
strncpy(lremotename, remotename, 128);
sregs.es = FP_SEG(lremotename);
regs.x.di = FP_OFF(lremotename);
}
result = intdosx(&regs, &regs, &sregs);
return(regs.x.cflag ? -result : 0);
}
int list_redir(int index, int *devicetyp, uint8 *devname, uint8 *remotename)
{
REGS regs;
SREGS sregs;
int result;
uint8 buff1[16];
uint8 buff2[128];
uint8 *ldevname = buff1;
uint8 *lremotename = buff2;
memset(ldevname, 0, sizeof(buff1));
memset(lremotename, 0, sizeof(buff2));
regs.x.ax = 0x5f02;
regs.x.bx = index;
regs.x.cx = 0x574e; /* user sign 'NW' */
sregs.ds = FP_SEG(ldevname);
regs.x.si = FP_OFF(ldevname);
sregs.es = FP_SEG(lremotename);
regs.x.di = FP_OFF(lremotename);
result = intdosx(&regs, &regs, &sregs);
if (!regs.x.cflag) {
if (devname) strcpy(devname, ldevname);
if (remotename) strcpy(remotename, lremotename);
if (devicetyp) *devicetyp = (int)regs.h.bl;
return((int)regs.h.bh);
} else return(-result);
}
int get_drive_info(uint8 drivenumber, uint8 *connid,
uint8 *dhandle, uint8 *statusflags)
/* drivenumber 0 .. 31 */
{
uint8 *drive_handle_table = get_shell_ptr(0xef00);
uint8 *drive_flag_table = get_shell_ptr(0xef01);
uint8 *drive_conn_table = get_shell_ptr(0xef02);
if ( !drive_handle_table
|| !drive_flag_table
|| !drive_conn_table
|| drivenumber > 31) {
char path[100];
if (drivenumber < 2 || !getcurdir(drivenumber+1, path)) {
*dhandle = 0;
*connid = 0;
*statusflags = 0x80;
return(0);
}
return(-1);
}
*dhandle = *(drive_handle_table+ drivenumber);
*connid = *(drive_conn_table + drivenumber);
*statusflags = *(drive_flag_table + drivenumber);
return(0);
}
typedef struct {
char fsname[8][48];
} SERVER_NAME_TABLE;
int get_fs_name(int connid, char *name)
/* Connection 1 .. 8 */
{
SERVER_NAME_TABLE *sf_t = get_shell_ptr(0xef04);
if (sf_t && connid > 0 && connid-- < 8){
strmaxcpy(name, sf_t->fsname[connid], 48);
return(0);
}
name[0] = '\0';
return(-11);
}
static char *path_env_name="PATH";
int get_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
/* maximal 16 Entries */
{
char *path=getglobenv(path_env_name);
SEARCH_VECTOR_ENTRY *v = vec;
int anz=0;
v->drivenummer = 0xff;
if (path){
while (*path && anz++ < 16){
char *p1 = path;
int len = 0;
while (*path && *path++ !=';') len++;
if (*(p1+1) == ':' && *p1 >= 'A' && *p1 <= 'Z') {
v->drivenummer = *p1 - 'A';
get_drive_info(v->drivenummer, &(v->connid),
&(v->dhandle), &(v->flags));
strmaxcpy(v->dospath, p1+2, min(len-2, sizeof(v->dospath)-1));
} else {
v->flags = 0;
v->drivenummer = 0xfe; /* ergibt ? */
strmaxcpy(v->dospath, p1, min(len, sizeof(v->dospath)-1));
}
(++v)->drivenummer = 0xff;
if (*path == ';') path++;
}
}
return(0);
}
int set_search_drive_vektor(SEARCH_VECTOR_ENTRY *vec)
{
char path[256];
char *p=path;
SEARCH_VECTOR_ENTRY *v;
int plen=strlen(path_env_name);
int maxcount=16;
strcpy(path, path_env_name);
path[plen] = '=';
path[++plen] = '\0';
while (maxcount-- && (NULL != (v = vec++)) && v->drivenummer != 0xff){
if (v->drivenummer < 26 || *(v->dospath)) {
if (p > path) *p++=';';
else p+=plen;
if (v->drivenummer < 26) {
*p++ = (char) v->drivenummer + 'A';
*p++ = ':';
if (*v->dospath) {
strcpy(p, v->dospath);
p+= strlen(v->dospath);
} else {
*p++='.';
*p ='\0';
}
} else {
strcpy(p, v->dospath);
p+= strlen(v->dospath);
}
}
}
return(putglobenv(path));
}
int alloc_dir_handle(int func,
int dhandle,
char *path,
int driveletter,
uint8 *effrights)
{
int pathlen = (path == NULL) ? 0 : strlen(path);
struct {
uint16 len;
uint8 func;
uint8 dhandle;
uint8 drive;
uint8 pathlen;
uint8 path[256];
} req;
struct {
uint16 len;
uint8 newhandle;
uint8 effrights;
} repl;
req.func = (uint8)func;
req.dhandle = (uint8)dhandle;
req.drive = (uint8)driveletter;
req.pathlen = (uint8)pathlen;
xmemmove(req.path, path, pathlen);
req.len = 4 + pathlen;
repl.len = 2;
/*
printf("alloc_dir_handle, path=%s, len=%d, disk=%c\n", path, pathlen, driveletter);
*/
neterrno = Net_Call(0xE200, &req, &repl);
fprintf(stderr, "neterrno=%d\n", neterrno);
if (neterrno && neterrno != 0xff) return(-1);
if (effrights) *effrights = repl.effrights;
return((int)repl.newhandle);
}
int dealloc_dir_handle(int dhandle)
{
struct {
uint16 len;
uint8 func;
uint8 dhandle;
} req;
struct {
uint16 len;
} repl;
req.len = 2;
req.func = 0x14;
req.dhandle = (uint8)dhandle;
repl.len = 0;
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno) return(-1);
else return(0);
}
int set_dir_path(uint8 desthandle, uint8 handle, char *path)
/* Set Directory Handle */
{
struct {
uint16 len;
uint8 func;
uint8 desth;
uint8 sourceh;
uint8 pathlen;
uint8 path[256];
} req;
struct {
uint16 len;
} repl;
req.pathlen = (path) ? strlen(path) : 0;
if (req.pathlen) memcpy(req.path, path, (int)req.pathlen);
req.len = 4+req.pathlen;
req.func = 0;
req.sourceh = handle;
req.desth = desthandle;
repl.len = 0;
neterrno = Net_Call(0xE200, &req, &repl);
return( (neterrno) ? -1 : 0);
}
int get_dir_path(uint8 dhandle, char *path)
{
struct {
uint16 len;
uint8 data[2];
} req;
struct {
uint16 len;
uint8 pathlen;
uint8 path[255];
} repl;
req.len = 2;
req.data[0] = 0x1;
req.data[1] = dhandle;
repl.len = 256;
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno) return(-1);
else {
strmaxcpy(path, repl.path, (int)repl.pathlen);
return(0);
}
}
int get_volume_name(uint8 nr, char *name)
{
struct {
uint16 len;
uint8 func;
uint8 nr;
} req;
struct {
uint16 len;
uint8 namlen;
uint8 name[16];
} repl;
req.len = 2;
req.func = 0x6;
req.nr = nr;
repl.len = 17;
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno) return(-1);
else {
strmaxcpy(name, repl.name, (int)repl.namlen);
return(0);
}
}
int save_dir_handle(uint8 dhandle, uint8 *savebuffer)
{
struct {
uint16 len;
uint8 func;
uint8 dhandle;
} req;
struct {
uint16 len;
uint8 savebuffer[16];
} repl;
req.len = 2;
req.func = 0x17;
req.dhandle = dhandle;
repl.len = 16;
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno) return(-1);
else {
xmemmove(savebuffer, repl.savebuffer, 16);
return(0);
}
}
int restore_dir_handle(uint8 *savebuffer, uint8 *dhandle, uint8 *effrights)
{
struct {
uint16 len;
uint8 func;
uint8 savebuffer[16];
} req;
struct {
uint16 len;
uint8 dhandle;
uint8 effrights;
} repl;
req.len = 17;
req.func = 0x18;
repl.len = 2;
xmemmove(req.savebuffer, savebuffer, 16);
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno) return(-1);
else {
*dhandle = repl.dhandle;
*effrights = repl.effrights;
return(0);
}
}
int mapdrive(uint8 connection, uint8 dhandle, char *path,
uint8 searchflag, uint8 searchorder,
uint8 *driveletter, uint8 *newdhandle, uint8 *effrights)
/* Searchorder 0 normal Drive; 1..16 Searchdrives */
/* searchflag only if Searchdrive : */
/* DRIVE_ADD, DRIVE_INSERT, DRIVE_DELETE */
{
return(-1);
}
Reference in New Issue View Git Blame Copy Permalink