1460 lines
32 KiB
C
1460 lines
32 KiB
C
#include "ncplib_user.h"
|
|
#include "nwcrypt.h"
|
|
|
|
typedef __u8 byte;
|
|
typedef __u16 word;
|
|
typedef __u32 dword;
|
|
|
|
#include <sys/ioctl.h>
|
|
#include <sys/wait.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <sys/time.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <fcntl.h>
|
|
#include "ipxutil.h"
|
|
|
|
#define ncp_printf printf
|
|
|
|
static void
|
|
assert_server_locked(struct ncp_server *server);
|
|
|
|
static void
|
|
assert_server_not_locked(struct ncp_server *server)
|
|
{
|
|
if (server->lock != 0) {
|
|
ncp_printf("ncpfs: server already locked!\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
ncp_lock_server(struct ncp_server *server)
|
|
{
|
|
assert_server_not_locked(server);
|
|
server->lock = 1;
|
|
}
|
|
|
|
static void
|
|
ncp_unlock_server(struct ncp_server *server)
|
|
{
|
|
assert_server_locked(server);
|
|
server->lock = 0;
|
|
}
|
|
|
|
static int
|
|
ncp_ioctl_request(struct ncp_server *server, int function) {
|
|
|
|
struct ncp_reply_header *reply
|
|
= (struct ncp_reply_header *)(server->ncp_data);
|
|
struct ncp_ioctl_request request;
|
|
int result;
|
|
|
|
assert_server_locked(server);
|
|
|
|
if (server->has_subfunction != 0) {
|
|
*(word *)(server->packet) = server->current_size - 2;
|
|
}
|
|
|
|
request.function = function;
|
|
request.size = server->current_size;
|
|
request.data = server->ncp_data;
|
|
|
|
if ((result = ioctl(server->mount_fid, NCP_IOC_NCPREQUEST,
|
|
&request)) < 0) {
|
|
return result;
|
|
}
|
|
|
|
server->ncp_reply_size = result - sizeof(struct ncp_reply_header);
|
|
|
|
result = reply->completion_code;
|
|
|
|
if ((result != 0)&&(server->silent==0)) {
|
|
ncp_printf("ncp_request_error: %d\n", result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static int
|
|
do_ncp_call(struct ncp_server *server, int request_size)
|
|
{
|
|
struct ncp_request_header request =
|
|
*((struct ncp_request_header *)(&(server->ncp_data)));
|
|
|
|
fd_set rd, wr, ex;
|
|
struct timeval tv;
|
|
|
|
int result;
|
|
int retries = 3;
|
|
|
|
while (retries > 0) {
|
|
retries -= 1;
|
|
|
|
result = sendto(server->ncp_sock, server->ncp_data,
|
|
request_size,
|
|
0, (struct sockaddr *)&(server->addr),
|
|
sizeof(server->addr));
|
|
|
|
if (result < 0) {
|
|
return result;
|
|
}
|
|
|
|
re_select:
|
|
FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
|
|
FD_SET(server->ncp_sock, &rd);
|
|
|
|
tv.tv_sec = 3;
|
|
tv.tv_usec = 0;
|
|
|
|
if (select(server->ncp_sock+1, &rd, &wr, &ex, &tv) == -1) {
|
|
perror("select");
|
|
return -1;
|
|
}
|
|
|
|
if (FD_ISSET(server->ncp_sock, &rd)) {
|
|
int len = recv(server->ncp_sock,
|
|
server->ncp_data, NCP_PACKET_SIZE,
|
|
0);
|
|
struct ncp_reply_header *r =
|
|
(struct ncp_reply_header *)&(server->ncp_data);
|
|
|
|
if ( (len == sizeof(*r))
|
|
&& (r->type == NCP_POSITIVE_ACK)) {
|
|
goto re_select;
|
|
}
|
|
if ( (len >= sizeof(*r))
|
|
&& (r->type == NCP_REPLY)
|
|
&& ( (request.type == NCP_ALLOC_SLOT_REQUEST)
|
|
|| ( (r->sequence == request.sequence)
|
|
&& (r->conn_low == request.conn_low)
|
|
&& (r->conn_high == request.conn_high)))) {
|
|
server->reply_size = len;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ncp_user_request(struct ncp_server *server, int function)
|
|
{
|
|
struct ncp_request_header *h =
|
|
(struct ncp_request_header *)&(server->ncp_data);
|
|
struct ncp_reply_header *r =
|
|
(struct ncp_reply_header *)&(server->ncp_data);
|
|
|
|
int result;
|
|
|
|
assert_server_locked(server);
|
|
|
|
if (server->has_subfunction != 0) {
|
|
*(__u16 *)(server->packet) = server->current_size - 2;
|
|
}
|
|
|
|
h->type = NCP_REQUEST;
|
|
|
|
server->sequence += 1;
|
|
h->sequence = server->sequence;
|
|
h->conn_low = (server->connection) & 0xff;
|
|
h->conn_high = ((server->connection) & 0xff00) >> 8;
|
|
h->task = 1;
|
|
h->function = function;
|
|
|
|
if (do_ncp_call(server, server->current_size + sizeof(*h)) != 0) {
|
|
return -1;
|
|
}
|
|
|
|
server->completion = r->completion_code;
|
|
server->conn_status = r->connection_state;
|
|
server->ncp_reply_size =
|
|
server->reply_size - sizeof(struct ncp_reply_header);
|
|
|
|
result = r->completion_code;
|
|
|
|
if (result != 0) {
|
|
ncp_printf("ncp_completion_code: %d\n", result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
int
|
|
install_wdog(struct ncp_server *server)
|
|
{
|
|
int parent_pid = getpid();
|
|
int pid;
|
|
int sock = server->wdog_sock;
|
|
|
|
fd_set rd, wr, ex;
|
|
struct timeval tv;
|
|
char buf[1024];
|
|
struct sockaddr_ipx sender;
|
|
int sizeofaddr = sizeof(struct sockaddr_ipx);
|
|
int pktsize;
|
|
|
|
|
|
if ((pid = fork()) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (pid != 0) {
|
|
/* Parent, should go on as usual */
|
|
server->wdog_pid = pid;
|
|
return 0;
|
|
}
|
|
|
|
while (1) {
|
|
|
|
FD_ZERO(&rd); FD_ZERO(&wr); FD_ZERO(&ex);
|
|
FD_SET(sock, &rd);
|
|
|
|
/* every 120 seconds we look if our parent is
|
|
still alive */
|
|
tv.tv_sec = 120;
|
|
tv.tv_usec = 0;
|
|
|
|
if (select(sock+1, &rd, &wr, &ex, &tv) == -1) {
|
|
continue;
|
|
}
|
|
|
|
if (getppid() != parent_pid) {
|
|
/* our parent has died, so nothing to do
|
|
anymore */
|
|
exit(0);
|
|
}
|
|
|
|
if (FD_ISSET(sock, &rd)) {
|
|
pktsize = recvfrom(sock, buf, sizeof(buf), 0,
|
|
(struct sockaddr *)&sender,
|
|
&sizeofaddr);
|
|
if (pktsize < 0) {
|
|
perror("recvfrom");
|
|
continue;
|
|
}
|
|
if ( (pktsize != 2)
|
|
|| (buf[1] != '?')) {
|
|
continue;
|
|
}
|
|
buf[1] = 'Y';
|
|
pktsize = sendto(sock, buf, 2, 0,
|
|
(struct sockaddr *)&sender,
|
|
sizeof(sender));
|
|
if (pktsize < 0) {
|
|
perror("send");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int
|
|
ncp_connect(struct ncp_server *server)
|
|
{
|
|
struct ncp_request_header *h =
|
|
(struct ncp_request_header *)&(server->ncp_data);
|
|
|
|
struct sockaddr_ipx addr;
|
|
int len = sizeof(struct sockaddr_ipx);
|
|
|
|
int ncp_sock, wdog_sock;
|
|
int ncp_port, wdog_port;
|
|
|
|
server->is_connected = NOT_CONNECTED;
|
|
|
|
ncp_sock = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
|
|
if (ncp_sock == -1) {
|
|
perror("open ncp socket");
|
|
return -1;
|
|
}
|
|
|
|
wdog_sock = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
|
|
if (wdog_sock == -1) {
|
|
perror("open wdog socket");
|
|
close(ncp_sock);
|
|
return -1;
|
|
}
|
|
|
|
addr.sipx_family = AF_IPX;
|
|
addr.sipx_network = htonl(0x0);
|
|
ipx_assign_node(addr.sipx_node, IPX_THIS_NODE);
|
|
addr.sipx_port = htons(0x0);
|
|
addr.sipx_type = NCP_PTYPE;
|
|
|
|
if (bind(ncp_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
|
|
perror("bind ncp socket");
|
|
close(ncp_sock); close(wdog_sock);
|
|
return -1;
|
|
}
|
|
|
|
if (bind(wdog_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
|
|
perror("bind wdog socket");
|
|
close(ncp_sock); close(wdog_sock);
|
|
return -1;
|
|
}
|
|
|
|
if ( (getsockname(ncp_sock, (struct sockaddr *)&addr, &len) != 0)
|
|
|| (len != sizeof(struct sockaddr_ipx))) {
|
|
perror("getsockname ncp socket");
|
|
close(ncp_sock); close(wdog_sock);
|
|
return -1;
|
|
}
|
|
ncp_port = ntohs(addr.sipx_port);
|
|
|
|
if ( (getsockname(wdog_sock, (struct sockaddr *)&addr, &len) != 0)
|
|
|| (len != sizeof(struct sockaddr_ipx))) {
|
|
perror("getsockname wdog socket");
|
|
close(wdog_sock); close(wdog_sock);
|
|
return -1;
|
|
}
|
|
wdog_port = ntohs(addr.sipx_port);
|
|
|
|
if (wdog_port != ncp_port+1) {
|
|
fprintf(stderr, "did not alloc 2 consecutive ports\n");
|
|
close(ncp_sock); close(wdog_sock);
|
|
return -1;
|
|
}
|
|
|
|
server->ncp_sock = ncp_sock;
|
|
server->wdog_sock = wdog_sock;
|
|
|
|
h->type = NCP_ALLOC_SLOT_REQUEST;
|
|
|
|
server->sequence = 0;
|
|
h->sequence = server->sequence;
|
|
h->conn_low = 0xff;
|
|
h->conn_high = 0xff;
|
|
h->task = 1;
|
|
h->function = 0;
|
|
|
|
if (do_ncp_call(server, sizeof(*h)) != 0) {
|
|
int saved_errno = errno;
|
|
close(ncp_sock); close(wdog_sock);
|
|
errno = saved_errno;
|
|
return -1;
|
|
}
|
|
|
|
install_wdog(server);
|
|
|
|
server->sequence = 0;
|
|
server->connection = h->conn_low + (h->conn_high * 256);
|
|
|
|
server->is_connected = CONN_SOCKET;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ncp_user_disconnect(struct ncp_server *server)
|
|
{
|
|
struct ncp_request_header *h
|
|
= (struct ncp_request_header *)(server->ncp_data);
|
|
int result;
|
|
|
|
h->type = NCP_DEALLOC_SLOT_REQUEST;
|
|
|
|
server->sequence += 1;
|
|
h->sequence = server->sequence;
|
|
h->conn_low = (server->connection) & 0xff;
|
|
h->conn_high = ((server->connection) & 0xff00) >> 8;
|
|
h->task = 1;
|
|
h->function = 0;
|
|
|
|
if ((result = do_ncp_call(server, sizeof(*h))) != 0) {
|
|
return result;
|
|
}
|
|
|
|
close(server->ncp_sock);
|
|
close(server->wdog_sock);
|
|
kill(server->wdog_pid, SIGTERM);
|
|
wait(NULL);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
ncp_disconnect(struct ncp_server *server)
|
|
{
|
|
int result = -1;
|
|
|
|
switch (server->is_connected) {
|
|
case CONN_MOUNTED:
|
|
result = close(server->mount_fid);
|
|
case CONN_SOCKET:
|
|
result = ncp_user_disconnect(server);
|
|
default:
|
|
}
|
|
if (result >= 0) {
|
|
server->is_connected = NOT_CONNECTED;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
int
|
|
ncp_connect_mount(struct ncp_server *server, const char *mount_point)
|
|
{
|
|
server->mount_fid = open(mount_point, O_RDONLY, 0);
|
|
|
|
if (server->mount_fid == -1) {
|
|
return -1;
|
|
|
|
}
|
|
|
|
server->is_connected = CONN_MOUNTED;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ncp_request(struct ncp_server *server, int function)
|
|
{
|
|
switch (server->is_connected) {
|
|
case CONN_MOUNTED:
|
|
return ncp_ioctl_request(server, function);
|
|
case CONN_SOCKET:
|
|
return ncp_user_request(server, function);
|
|
default:
|
|
}
|
|
return -ENOTCONN;
|
|
}
|
|
|
|
static inline int
|
|
min(int a, int b) {
|
|
if (a<b)
|
|
return a;
|
|
else
|
|
return b;
|
|
}
|
|
|
|
static void
|
|
assert_server_locked(struct ncp_server *server)
|
|
{
|
|
if (server->lock == 0) {
|
|
ncp_printf("ncpfs: server not locked!\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
ncp_add_byte(struct ncp_server *server, byte x)
|
|
{
|
|
assert_server_locked(server);
|
|
*(byte *)(&(server->packet[server->current_size])) = x;
|
|
server->current_size += 1;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ncp_add_word(struct ncp_server *server, word x)
|
|
{
|
|
assert_server_locked(server);
|
|
*(word *)(&(server->packet[server->current_size])) = x;
|
|
server->current_size += 2;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ncp_add_dword(struct ncp_server *server, dword x)
|
|
{
|
|
assert_server_locked(server);
|
|
*(dword *)(&(server->packet[server->current_size])) = x;
|
|
server->current_size += 4;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ncp_add_mem(struct ncp_server *server, const void *source, int size)
|
|
{
|
|
assert_server_locked(server);
|
|
memcpy(&(server->packet[server->current_size]), source, size);
|
|
server->current_size += size;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ncp_add_pstring(struct ncp_server *server, const char *s)
|
|
{
|
|
int len = strlen(s);
|
|
assert_server_locked(server);
|
|
if (len > 255) {
|
|
ncp_printf("ncpfs: string too long: %s\n", s);
|
|
len = 255;
|
|
}
|
|
ncp_add_byte(server, len);
|
|
ncp_add_mem(server, s, len);
|
|
return;
|
|
}
|
|
|
|
static void
|
|
ncp_init_request(struct ncp_server *server)
|
|
{
|
|
ncp_lock_server(server);
|
|
|
|
server->current_size = 0;
|
|
server->packet =
|
|
&(server->ncp_data[sizeof(struct ncp_request_header)]);
|
|
server->has_subfunction = 0;
|
|
}
|
|
|
|
static void
|
|
ncp_init_request_s(struct ncp_server *server, int subfunction)
|
|
{
|
|
ncp_init_request(server);
|
|
ncp_add_word(server, 0); /* preliminary size */
|
|
|
|
ncp_add_byte(server, subfunction);
|
|
|
|
server->has_subfunction = 1;
|
|
}
|
|
|
|
static char *
|
|
ncp_reply_data(struct ncp_server *server, int offset)
|
|
{
|
|
return &(server->ncp_data[sizeof(struct ncp_reply_header) + offset]);
|
|
}
|
|
|
|
static byte
|
|
ncp_reply_byte(struct ncp_server *server, int offset)
|
|
{
|
|
return *(byte *)(ncp_reply_data(server, offset));
|
|
}
|
|
|
|
static word
|
|
ncp_reply_word(struct ncp_server *server, int offset)
|
|
{
|
|
return *(word *)(ncp_reply_data(server, offset));
|
|
}
|
|
|
|
static dword
|
|
ncp_reply_dword(struct ncp_server *server, int offset)
|
|
{
|
|
return *(dword *)(ncp_reply_data(server, offset));
|
|
}
|
|
|
|
int
|
|
ncp_negotiate_buffersize(struct ncp_server *server,
|
|
int size, int *target) {
|
|
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_word(server, htons(size));
|
|
|
|
if ((result = ncp_request(server, 33)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
*target =min(ntohs(ncp_reply_word(server, 0)), size);
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* result is a 8-byte buffer
|
|
*/
|
|
int
|
|
ncp_get_encryption_key(struct ncp_server *server,
|
|
char *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 23);
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
if (server->ncp_reply_size < 8) {
|
|
ncp_printf("ncp_reply_size %d < 8\n",
|
|
server->ncp_reply_size);
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(target, ncp_reply_data(server, 0), 8);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_get_bindery_object_id(struct ncp_server *server,
|
|
int object_type, char *object_name,
|
|
struct ncp_bindery_object *target)
|
|
{
|
|
int result;
|
|
ncp_init_request_s(server, 53);
|
|
ncp_add_word(server, htons(object_type));
|
|
ncp_add_pstring(server, object_name);
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
if (server->ncp_reply_size < 54) {
|
|
ncp_printf("ncp_reply_size %d < 54\n",
|
|
server->ncp_reply_size);
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
target->object_id = ntohl(ncp_reply_dword(server, 0));
|
|
target->object_type = ntohs(ncp_reply_word (server, 4));
|
|
memcpy(target->object_name, ncp_reply_data(server, 6), 48);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_read_property_value(struct ncp_server *server,
|
|
int object_type, char *object_name,
|
|
int segment, char *prop_name,
|
|
struct nw_property *target)
|
|
{
|
|
int result;
|
|
ncp_init_request_s(server, 61);
|
|
ncp_add_word(server, htons(object_type));
|
|
ncp_add_pstring(server, object_name);
|
|
ncp_add_byte(server, segment);
|
|
ncp_add_pstring(server, prop_name);
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(&(target->value), ncp_reply_data(server, 0), 128);
|
|
target->more_flag = ncp_reply_byte(server, 128);
|
|
target->property_flag = ncp_reply_byte(server, 129);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_login_encrypted(struct ncp_server *server,
|
|
struct ncp_bindery_object *object,
|
|
unsigned char *key,
|
|
unsigned char *passwd)
|
|
{
|
|
dword tmpID = htonl(object->object_id);
|
|
unsigned char buf[128];
|
|
unsigned char encrypted[8];
|
|
int result;
|
|
|
|
shuffle((byte *)&tmpID, passwd, strlen(passwd), buf);
|
|
nw_encrypt(key, buf, encrypted);
|
|
|
|
ncp_init_request_s(server, 24);
|
|
ncp_add_mem(server, encrypted, 8);
|
|
ncp_add_word(server, htons(object->object_type));
|
|
ncp_add_pstring(server, object->object_name);
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_login_user(struct ncp_server *server,
|
|
unsigned char *username,
|
|
unsigned char *password)
|
|
{
|
|
int result;
|
|
unsigned char ncp_key[8];
|
|
struct ncp_bindery_object user;
|
|
|
|
if ((result = ncp_get_encryption_key(server, ncp_key)) != 0) {
|
|
return result;
|
|
}
|
|
|
|
if ((result = ncp_get_bindery_object_id(server, NCP_BINDERY_USER,
|
|
username, &user)) != 0) {
|
|
return result;
|
|
}
|
|
|
|
if ((result = ncp_login_encrypted(server, &user,
|
|
ncp_key, password)) != 0) {
|
|
return result;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
ncp_get_volume_info_with_number(struct ncp_server *server, int n,
|
|
struct ncp_volume_info *target)
|
|
{
|
|
int result;
|
|
int len;
|
|
|
|
ncp_init_request_s(server, 44);
|
|
ncp_add_byte(server, n);
|
|
|
|
if ((result = ncp_request(server, 22)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
target->total_blocks = ncp_reply_dword(server, 0);
|
|
target->free_blocks = ncp_reply_dword(server, 4);
|
|
target->purgeable_blocks = ncp_reply_dword(server, 8);
|
|
target->not_yet_purgeable_blocks = ncp_reply_dword(server, 12);
|
|
target->total_dir_entries = ncp_reply_dword(server, 16);
|
|
target->available_dir_entries = ncp_reply_dword(server, 20);
|
|
target->sectors_per_block = ncp_reply_byte(server, 28);
|
|
|
|
memset(&(target->volume_name), 0, sizeof(target->volume_name));
|
|
|
|
len = ncp_reply_byte(server, 29);
|
|
if (len > NCP_VOLNAME_LEN) {
|
|
ncp_printf("ncpfs: volume name too long: %d\n", len);
|
|
ncp_unlock_server(server);
|
|
return -EIO;
|
|
}
|
|
|
|
memcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_get_volume_number(struct ncp_server *server, const char *name, int *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 5);
|
|
ncp_add_pstring(server, name);
|
|
|
|
if ((result = ncp_request(server, 22)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
*target = ncp_reply_byte(server, 0);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
ncp_file_search_init(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
struct ncp_filesearch_info *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, 62)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
target->volume_number = ncp_reply_byte(server, 0);
|
|
target->directory_id = ntohs(ncp_reply_word(server, 1));
|
|
target->sequence_no = ntohs(ncp_reply_word(server, 3));
|
|
target->access_rights = ncp_reply_byte(server, 5);
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
ncp_file_search_continue(struct ncp_server *server,
|
|
struct ncp_filesearch_info *fsinfo,
|
|
int attributes, const char *name,
|
|
struct ncp_file_info *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
|
|
ncp_add_byte(server, fsinfo->volume_number);
|
|
ncp_add_word(server, htons(fsinfo->directory_id));
|
|
ncp_add_word(server, htons(fsinfo->sequence_no));
|
|
|
|
ncp_add_byte(server, attributes);
|
|
ncp_add_pstring(server, name);
|
|
|
|
if ((result = ncp_request(server, 63)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
fsinfo->sequence_no = ntohs(ncp_reply_word(server, 0));
|
|
|
|
memset(&(target->file_name), 0, sizeof(target->file_name));
|
|
memcpy(&(target->file_name), ncp_reply_data(server, 4),
|
|
NCP_MAX_FILENAME);
|
|
|
|
target->file_attributes = ncp_reply_byte(server, 18);
|
|
target->file_mode = ncp_reply_byte(server, 19);
|
|
target->file_length = ntohl(ncp_reply_dword(server, 20));
|
|
target->creation_date = ntohs(ncp_reply_word(server, 24));
|
|
target->access_date = ntohs(ncp_reply_word(server, 26));
|
|
target->update_date = ntohs(ncp_reply_word(server, 28));
|
|
target->update_time = ntohs(ncp_reply_word(server, 30));
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_get_finfo(struct ncp_server *server,
|
|
int dir_handle, const char *path, const char *name,
|
|
struct ncp_file_info *target)
|
|
{
|
|
int result;
|
|
|
|
struct ncp_filesearch_info fsinfo;
|
|
|
|
if ((result = ncp_file_search_init(server, dir_handle, path,
|
|
&fsinfo)) != 0) {
|
|
return result;
|
|
}
|
|
|
|
if ((result = ncp_file_search_continue(server, &fsinfo, 0, name,
|
|
target)) == 0) {
|
|
return result;
|
|
}
|
|
|
|
if ((result = ncp_file_search_init(server, dir_handle, path,
|
|
&fsinfo)) != 0) {
|
|
return result;
|
|
}
|
|
|
|
return ncp_file_search_continue(server, &fsinfo, aDIR, name, target);
|
|
}
|
|
|
|
int
|
|
ncp_open_file(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int attr, int access,
|
|
struct ncp_file_info *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_byte(server, attr);
|
|
ncp_add_byte(server, access);
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, 76)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(&(target->file_id), ncp_reply_data(server, 0),
|
|
NCP_FILE_ID_LEN);
|
|
|
|
memset(&(target->file_name), 0, sizeof(target->file_name));
|
|
memcpy(&(target->file_name), ncp_reply_data(server, 8),
|
|
NCP_MAX_FILENAME);
|
|
|
|
target->file_attributes = ncp_reply_byte(server, 22);
|
|
target->file_mode = ncp_reply_byte(server, 23);
|
|
target->file_length = ntohl(ncp_reply_dword(server, 24));
|
|
target->creation_date = ntohs(ncp_reply_word(server, 28));
|
|
target->access_date = ntohs(ncp_reply_word(server, 30));
|
|
target->update_date = ntohs(ncp_reply_word(server, 32));
|
|
target->update_time = ntohs(ncp_reply_word(server, 34));
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_close_file(struct ncp_server *server, const char *file_id)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 0);
|
|
ncp_add_mem(server, file_id, 6);
|
|
|
|
if ((result = ncp_request(server, 66)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ncp_do_create(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int attr,
|
|
struct ncp_file_info *target,
|
|
int function)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_byte(server, attr);
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, function)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(&(target->file_id), ncp_reply_data(server, 0),
|
|
NCP_FILE_ID_LEN);
|
|
|
|
memset(&(target->file_name), 0, sizeof(target->file_name));
|
|
memcpy(&(target->file_name), ncp_reply_data(server, 8),
|
|
NCP_MAX_FILENAME);
|
|
|
|
target->file_attributes = ncp_reply_byte(server, 22);
|
|
target->file_mode = ncp_reply_byte(server, 23);
|
|
target->file_length = ntohl(ncp_reply_dword(server, 24));
|
|
target->creation_date = ntohs(ncp_reply_word(server, 28));
|
|
target->access_date = ntohs(ncp_reply_word(server, 30));
|
|
target->update_date = ntohs(ncp_reply_word(server, 32));
|
|
target->update_time = ntohs(ncp_reply_word(server, 34));
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_create_newfile(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int attr,
|
|
struct ncp_file_info *target)
|
|
{
|
|
return ncp_do_create(server, dir_handle, path, attr, target, 77);
|
|
}
|
|
|
|
int
|
|
ncp_create_file(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int attr,
|
|
struct ncp_file_info *target)
|
|
{
|
|
return ncp_do_create(server, dir_handle, path, attr, target, 67);
|
|
}
|
|
|
|
int
|
|
ncp_erase_file(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int attr)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_byte(server, attr);
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, 68)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_rename_file(struct ncp_server *server,
|
|
int old_handle, const char *old_path,
|
|
int attr,
|
|
int new_handle, const char *new_path)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, old_handle);
|
|
ncp_add_byte(server, attr);
|
|
ncp_add_pstring(server, old_path);
|
|
ncp_add_byte(server, new_handle);
|
|
ncp_add_pstring(server, new_path);
|
|
|
|
if ((result = ncp_request(server, 69)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_create_directory(struct ncp_server *server,
|
|
int dir_handle, const char *path,
|
|
int inherit_mask)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 10);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_byte(server, inherit_mask);
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, 22)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_delete_directory(struct ncp_server *server,
|
|
int dir_handle, const char *path)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 11);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_pstring(server, path);
|
|
|
|
if ((result = ncp_request(server, 22)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_rename_directory(struct ncp_server *server,
|
|
int dir_handle,
|
|
const char *old_path, const char *new_path)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 15);
|
|
ncp_add_byte(server, dir_handle);
|
|
ncp_add_pstring(server, old_path);
|
|
ncp_add_pstring(server, new_path);
|
|
|
|
if ((result = ncp_request(server, 22)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void
|
|
ncp_add_handle_path(struct ncp_server *server,
|
|
__u8 vol_num,
|
|
__u32 dir_base, int have_dir_base,
|
|
char *path)
|
|
{
|
|
ncp_add_byte(server, vol_num);
|
|
ncp_add_dword(server, dir_base);
|
|
if (have_dir_base != 0) {
|
|
ncp_add_byte(server, 1); /* dir_base */
|
|
} else {
|
|
ncp_add_byte(server, 0xff); /* no handle */
|
|
}
|
|
if (path != NULL) {
|
|
ncp_add_byte(server, 1); /* 1 component */
|
|
ncp_add_pstring(server, path);
|
|
}
|
|
else
|
|
{
|
|
ncp_add_byte(server, 0);
|
|
}
|
|
}
|
|
|
|
static void
|
|
ncp_extract_file_info(void *structure, struct nw_info_struct *target)
|
|
{
|
|
__u8 *name_len;
|
|
const int info_struct_size = sizeof(struct nw_info_struct) - 257;
|
|
|
|
memcpy(target, structure, info_struct_size);
|
|
name_len = structure + info_struct_size;
|
|
target->nameLen = *name_len;
|
|
strncpy(target->entryName, name_len+1, *name_len);
|
|
target->entryName[*name_len] = '\0';
|
|
return;
|
|
}
|
|
|
|
int
|
|
ncp_do_lookup(struct ncp_server *server,
|
|
struct nw_info_struct *dir,
|
|
char *path, /* may only be one component */
|
|
struct nw_info_struct *target)
|
|
{
|
|
__u8 vol_num;
|
|
__u32 dir_base;
|
|
int result;
|
|
char *volname = NULL;
|
|
|
|
if (target == NULL) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (dir == NULL) {
|
|
|
|
/* Access a volume's root directory */
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 22); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_handle_path(server, 0, 0, 0, /* no handle */
|
|
path);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
dir_base = ncp_reply_dword(server, 4);
|
|
vol_num = ncp_reply_byte (server, 8);
|
|
ncp_unlock_server(server);
|
|
volname = path;
|
|
path = NULL;
|
|
}
|
|
else
|
|
{
|
|
vol_num = dir->volNumber;
|
|
dir_base = dir->DosDirNum;
|
|
}
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 6); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* dos name space as dest */
|
|
ncp_add_word(server, 0xff); /* get all */
|
|
ncp_add_dword(server, RIM_ALL);
|
|
ncp_add_handle_path(server, vol_num, dir_base, 1,
|
|
path);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_extract_file_info(ncp_reply_data(server, 0), target);
|
|
|
|
if (volname != NULL) {
|
|
target->nameLen = strlen(volname);
|
|
strcpy(target->entryName, volname);
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
|
|
struct nw_info_struct *file,
|
|
__u32 info_mask,
|
|
struct nw_modify_dos_info *info)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 7); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_word(server, 0x8006); /* search attribs: all */
|
|
|
|
ncp_add_dword(server, info_mask);
|
|
ncp_add_mem(server, info, sizeof(*info));
|
|
ncp_add_handle_path(server, file->volNumber,
|
|
file->DosDirNum, 1, NULL);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
ncp_del_file_or_subdir(struct ncp_server *server,
|
|
struct nw_info_struct *dir, char *name)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 8); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_word(server, 0x8006); /* search attribs: all */
|
|
ncp_add_handle_path(server, dir->volNumber,
|
|
dir->DosDirNum, 1, name);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
static inline void
|
|
ConvertToNWfromDWORD ( __u32 sfd , __u8 ret[6] )
|
|
{
|
|
__u16 *dest = (__u16 *) ret;
|
|
memcpy(&(dest[1]), &sfd, 4);
|
|
dest[0] = dest[1] + 1;
|
|
return;
|
|
}
|
|
|
|
int
|
|
ncp_open_create_file_or_subdir(struct ncp_server *server,
|
|
struct nw_info_struct *dir, char *name,
|
|
int open_create_mode,
|
|
__u32 create_attributes,
|
|
int desired_acc_rights,
|
|
struct nw_file_info *target)
|
|
{
|
|
int result;
|
|
|
|
target->opened = 0;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 1); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, open_create_mode);
|
|
ncp_add_word(server, 0x8006);
|
|
ncp_add_dword(server, RIM_ALL);
|
|
ncp_add_dword(server, create_attributes);
|
|
/* The desired acc rights seem to be the inherited rights mask
|
|
for directories */
|
|
ncp_add_word(server, desired_acc_rights);
|
|
ncp_add_handle_path(server, dir->volNumber,
|
|
dir->DosDirNum, 1, name);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
target->opened = 1;
|
|
target->server_file_handle = ncp_reply_dword(server, 0);
|
|
target->open_create_action = ncp_reply_byte(server, 4);
|
|
ncp_extract_file_info(ncp_reply_data(server, 5), &(target->i));
|
|
ConvertToNWfromDWORD(target->server_file_handle, target->file_handle);
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_initialize_search(struct ncp_server *server,
|
|
struct nw_info_struct *dir,
|
|
struct nw_search_sequence *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 2); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* reserved */
|
|
ncp_add_handle_path(server, dir->volNumber,
|
|
dir->DosDirNum, 1, NULL);
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(target, ncp_reply_data(server, 0), sizeof(*target));
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
/* Search for everything */
|
|
int
|
|
ncp_search_for_file_or_subdir(struct ncp_server *server,
|
|
struct nw_search_sequence *seq,
|
|
struct nw_info_struct *target)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 3); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 0); /* data stream (???) */
|
|
ncp_add_word(server, 0xffff); /* Search attribs */
|
|
ncp_add_dword(server, RIM_ALL); /* return info mask */
|
|
ncp_add_mem(server, seq, 9);
|
|
ncp_add_byte(server, 2); /* 2 byte pattern */
|
|
ncp_add_byte(server, 0xff); /* following is a wildcard */
|
|
ncp_add_byte(server, '*');
|
|
|
|
if ((result = ncp_request(server, 87)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
|
|
ncp_extract_file_info(ncp_reply_data(server, 10), target);
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
|
|
struct nw_info_struct *old_dir, char *old_name,
|
|
struct nw_info_struct *new_dir, char *new_name)
|
|
{
|
|
int result;
|
|
|
|
if ( (old_dir == NULL) || (old_name == NULL)
|
|
|| (new_dir == NULL) || (new_name == NULL))
|
|
return -EINVAL;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 4); /* subfunction */
|
|
ncp_add_byte(server, 0); /* dos name space */
|
|
ncp_add_byte(server, 1); /* rename flag */
|
|
ncp_add_word(server, 0x8006); /* search attributes */
|
|
|
|
/* source Handle Path */
|
|
ncp_add_byte(server, old_dir->volNumber);
|
|
ncp_add_dword(server, old_dir->DosDirNum);
|
|
ncp_add_byte(server, 1);
|
|
ncp_add_byte(server, 1); /* 1 source component */
|
|
|
|
/* dest Handle Path */
|
|
ncp_add_byte(server, new_dir->volNumber);
|
|
ncp_add_dword(server, new_dir->DosDirNum);
|
|
ncp_add_byte(server, 1);
|
|
ncp_add_byte(server, 1); /* 1 destination component */
|
|
|
|
/* source path string */
|
|
ncp_add_pstring(server, old_name);
|
|
/* dest path string */
|
|
ncp_add_pstring(server, new_name);
|
|
|
|
result = ncp_request(server, 87);
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Create a new job entry */
|
|
int
|
|
ncp_create_queue_job_and_file(struct ncp_server *server,
|
|
__u32 queue_id,
|
|
struct queue_job *job)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 121);
|
|
ncp_add_dword(server, htonl(queue_id));
|
|
ncp_add_mem(server, &(job->j), sizeof(job->j));
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
memcpy(&(job->j), ncp_reply_data(server, 0), 78);
|
|
|
|
ConvertToNWfromDWORD(job->j.JobFileHandle, job->file_handle);
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_close_file_and_start_job(struct ncp_server *server,
|
|
__u32 queue_id,
|
|
struct queue_job *job)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request_s(server, 127);
|
|
ncp_add_dword(server, htonl(queue_id));
|
|
ncp_add_dword(server, job->j.JobNumber);
|
|
|
|
if ((result = ncp_request(server, 23)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_read(struct ncp_server *server, const char *file_id,
|
|
__u32 offset, __u16 to_read,
|
|
char *target, int *bytes_read)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 0);
|
|
ncp_add_mem(server, file_id, 6);
|
|
ncp_add_dword(server, htonl(offset));
|
|
ncp_add_word(server, htons(to_read));
|
|
|
|
if ((result = ncp_request(server, 72)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
*bytes_read = ntohs(ncp_reply_word(server, 0));
|
|
|
|
memcpy(target, ncp_reply_data(server, 2), *bytes_read);
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
ncp_write(struct ncp_server *server, const char *file_id,
|
|
__u32 offset, __u16 to_write,
|
|
const char *source, int *bytes_written)
|
|
{
|
|
int result;
|
|
|
|
ncp_init_request(server);
|
|
ncp_add_byte(server, 0);
|
|
ncp_add_mem(server, file_id, 6);
|
|
ncp_add_dword(server, htonl(offset));
|
|
ncp_add_word(server, htons(to_write));
|
|
ncp_add_mem(server, source, to_write);
|
|
|
|
if ((result = ncp_request(server, 73)) != 0) {
|
|
ncp_unlock_server(server);
|
|
return result;
|
|
}
|
|
|
|
*bytes_written = to_write;
|
|
|
|
ncp_unlock_server(server);
|
|
return 0;
|
|
}
|
|
|