mars_nwe/ncpfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Import ncpfs 2.0.9

Browse Source
This commit is contained in:
ncpfs archive import
2026-04-28 20:39:58 +02:00
parent fff159f2db
commit f88460b2e6
50 changed files with 3616 additions and 3076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
.downloads/ncpfs-2.0.9.tgz Normal file
View File

Binary file not shown.

5
Changes
View File

@@ -1,6 +1,11 @@
I only began this file with ncpfs-0.12. If you're interested in older
versions, you can find them on ftp.gwdg.de:/pub/linux/misc/ncpfs/old.
ncpfs-2.0.8 -> ncpfs-2.0.9
- Added patches directory
- Added nwvolinfo and nwtrustee. Thanks to Jacek Stepniewski <cunio@gazeta.pl>
- nwpasswd can change other's passwords. Thanks to Martin Stover.
ncpfs-2.0.7 -> ncpfs-2.0.8
- Fixed util/Makefile for easier optimization handling. Thanks to Rik
Faith <faith@cs.unc.edu> for this one

6
Makefile
View File

@@ -2,11 +2,11 @@
# Makefile for the linux ncp-filesystem routines.
#
VERSION = 2.0.8
VERSION = 2.0.9
# If you are using kerneld to autoload ncp support,
# uncomment this (kerneld is in linux since about 1.3.57):
#KERNELD = -DHAVE_KERNELD
KERNELD = -DHAVE_KERNELD
# If your system is ELF, either also do a 'make install', or append the util/
# directory where the dynamic library resides to the environment
@@ -29,7 +29,7 @@ INCLUDES += -I$(TOPDIR)/kernel-1.2
endif
COPT = -O2
# COPT += -g
COPT += -g
CFLAGS = $(COPT) -Wall $(INCLUDES) $(KERNELD) -DNCPFS_VERSION=\"$(VERSION)\"
export INCLUDES BINDIR SBINDIR KERNELD VERSION HAVE_ELF CFLAGS

12
TODO
View File

@@ -1,12 +0,0 @@
Here's a list of things I want to do. Feel free to send suggestions,
or even help me ;-).
- do rtt estimation, like tcp does.
- Do better connection management. I imagine to create a ncpd.
- When ncpd is done, one can think about mounting several volumes over
a single NCP connection. This should make the trade-off mentioned in
ncpmount.8 unnecessary.
- Do some kind of mapping of NCP uid's to unix uid's

28
include/com_err.h
View File

@@ -16,25 +16,25 @@ typedef long errcode_t;
#include <stdarg.h>
/* ANSI C -- use prototypes etc */
void com_err (const char *, long, const char *, ...);
void com_err_va (const char *whoami, errcode_t code, const char *fmt,
va_list args);
char const *error_message (long);
void com_err(const char *, long, const char *,...);
void com_err_va(const char *whoami, errcode_t code, const char *fmt,
va_list args);
char const *error_message(long);
extern void (*com_err_hook) (const char *, long, const char *, va_list);
void (*set_com_err_hook (void (*) (const char *, long, const char *, va_list)))
(const char *, long, const char *, va_list);
void (*reset_com_err_hook (void)) (const char *, long, const char *, va_list);
int init_error_table(const char * const *msgs, int base, int count);
void (*set_com_err_hook(void (*)(const char *, long, const char *, va_list)))
(const char *, long, const char *, va_list);
void (*reset_com_err_hook(void)) (const char *, long, const char *, va_list);
int init_error_table(const char *const *msgs, int base, int count);
#else
/* no prototypes */
void com_err ();
void com_err_va ();
char *error_message ();
void com_err();
void com_err_va();
char *error_message();
extern void (*com_err_hook) ();
void (*set_com_err_hook ()) ();
void (*reset_com_err_hook ()) ();
void (*set_com_err_hook()) ();
void (*reset_com_err_hook()) ();
int init_error_table();
#endif
#define __COM_ERR_H
#endif /* ! defined(__COM_ERR_H) */
#endif /* ! defined(__COM_ERR_H) */

69
include/ipxlib.h
View File

@@ -15,9 +15,9 @@
#include <linux/ipx.h>
#include <stdio.h>
typedef unsigned long IPXNet;
typedef unsigned long IPXNet;
typedef unsigned short IPXPort;
typedef unsigned char IPXNode[IPX_NODE_LEN];
typedef unsigned char IPXNode[IPX_NODE_LEN];
#define IPX_USER_PTYPE (0x00)
#define IPX_RIP_PTYPE (0x01)
@@ -33,30 +33,35 @@ typedef unsigned char IPXNode[IPX_NODE_LEN];
#define IPX_SAP_FILE_SERVER (0x0004)
struct sap_query {
unsigned short query_type; /* net order */
unsigned short server_type; /* net order */
struct sap_query
{
unsigned short query_type; /* net order */
unsigned short server_type; /* net order */
};
struct sap_server_ident {
unsigned short server_type __attribute__ ((packed));
char server_name[48] __attribute__ ((packed));
IPXNet server_network __attribute__ ((packed));
IPXNode server_node __attribute__ ((packed));
IPXPort server_port __attribute__ ((packed));
unsigned short intermediate_network __attribute__ ((packed));
struct sap_server_ident
{
unsigned short server_type __attribute__((packed));
char server_name[48] __attribute__((packed));
IPXNet server_network __attribute__((packed));
IPXNode server_node __attribute__((packed));
IPXPort server_port __attribute__((packed));
unsigned short intermediate_network __attribute__((packed));
};
#define IPX_RIP_REQUEST (0x1)
#define IPX_RIP_RESPONSE (0x2)
struct ipx_rip_packet {
__u16 operation __attribute__ ((packed));
struct ipx_rt_def {
__u32 network __attribute__ ((packed));
__u16 hops __attribute__ ((packed));
__u16 ticks __attribute__ ((packed));
} rt[1] __attribute__ ((packed));
struct ipx_rip_packet
{
__u16 operation __attribute__((packed));
struct ipx_rt_def
{
__u32 network __attribute__((packed));
__u16 hops __attribute__((packed));
__u16 ticks __attribute__((packed));
}
rt[1] __attribute__((packed));
};
#define IPX_BROADCAST_NODE ("\xff\xff\xff\xff\xff\xff")
@@ -68,26 +73,26 @@ struct ipx_rip_packet {
#endif
void
ipx_print_node(IPXNode node);
ipx_print_node(IPXNode node);
void
ipx_print_network(IPXNet net);
ipx_print_network(IPXNet net);
void
ipx_print_port(IPXPort port);
ipx_print_port(IPXPort port);
void
ipx_print_saddr(struct sockaddr_ipx* sipx);
ipx_print_saddr(struct sockaddr_ipx *sipx);
void
ipx_fprint_node(FILE *file, IPXNode node);
ipx_fprint_node(FILE * file, IPXNode node);
void
ipx_fprint_network(FILE *file, IPXNet net);
ipx_fprint_network(FILE * file, IPXNet net);
void
ipx_fprint_port(FILE *file, IPXPort port);
ipx_fprint_port(FILE * file, IPXPort port);
void
ipx_fprint_saddr(FILE *file, struct sockaddr_ipx* sipx);
ipx_fprint_saddr(FILE * file, struct sockaddr_ipx *sipx);
int
ipx_sscanf_node(char *buf, unsigned char node[IPX_NODE_LEN]);
ipx_sscanf_node(char *buf, unsigned char node[IPX_NODE_LEN]);
void
ipx_assign_node(IPXNode dest, IPXNode src);
ipx_assign_node(IPXNode dest, IPXNode src);
int
ipx_node_equal(IPXNode n1,IPXNode n2);
ipx_node_equal(IPXNode n1, IPXNode n2);
#endif /* _IPXLIB_H */
#endif /* _IPXLIB_H */

694
include/ncplib.h
View File

@@ -19,26 +19,115 @@
#include "ipxlib.h"
#include "com_err.h"
typedef __u8 byte;
typedef __u16 word;
typedef __u32 dword;
#ifndef memzero
#include <string.h>
#define memzero(object) memset(&(object), 0, sizeof(object))
#endif
void
str_upper(char *name);
#define BVAL(buf,pos) (((__u8 *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)BVAL(buf,pos))
#define BSET(buf,pos,val) (BVAL(buf,pos) = (val))
enum connect_state {
static inline word
WVAL_HL(__u8 * buf, int pos)
{
return PVAL(buf, pos) << 8 | PVAL(buf, pos + 1);
}
static inline dword
DVAL_HL(__u8 * buf, int pos)
{
return WVAL_HL(buf, pos) << 16 | WVAL_HL(buf, pos + 2);
}
static inline void
WSET_HL(__u8 * buf, int pos, word val)
{
BSET(buf, pos, val >> 8);
BSET(buf, pos + 1, val & 0xff);
}
static inline void
DSET_HL(__u8 * buf, int pos, dword val)
{
WSET_HL(buf, pos, val >> 16);
WSET_HL(buf, pos + 2, val & 0xffff);
}
/* we know that the 386 can handle misalignment and has the "right"
byteorder */
#if defined(__i386__)
static inline word
WVAL_LH(__u8 * buf, int pos)
{
return *((word *) (buf + pos));
}
static inline dword
DVAL_LH(__u8 * buf, int pos)
{
return *((dword *) (buf + pos));
}
static inline void
WSET_LH(__u8 * buf, int pos, word val)
{
*((word *) (buf + pos)) = val;
}
static inline void
DSET_LH(__u8 * buf, int pos, dword val)
{
*((dword *) (buf + pos)) = val;
}
#else
static inline word
WVAL_LH(__u8 * buf, int pos)
{
return PVAL(buf, pos) | PVAL(buf, pos + 1) << 8;
}
static inline dword
DVAL_LH(__u8 * buf, int pos)
{
return WVAL_LH(buf, pos) | WVAL_LH(buf, pos + 2) << 16;
}
static inline void
WSET_LH(__u8 * buf, int pos, word val)
{
BSET(buf, pos, val & 0xff);
BSET(buf, pos + 1, val >> 8);
}
static inline void
DSET_LH(__u8 * buf, int pos, dword val)
{
WSET_LH(buf, pos, val & 0xffff);
WSET_LH(buf, pos + 2, val >> 16);
}
#endif
void
str_upper(char *name);
enum connect_state
{
NOT_CONNECTED = 0,
CONN_PERMANENT,
CONN_TEMPORARY
};
struct ncp_conn {
struct ncp_conn
{
enum connect_state is_connected;
char server[NCP_BINDERY_NAME_LEN];
char user [NCP_BINDERY_NAME_LEN];
char user[NCP_BINDERY_NAME_LEN];
struct ncp_fs_info i;
@@ -66,7 +155,8 @@ struct ncp_conn {
char packet[NCP_PACKET_SIZE];
};
struct ncp_conn_spec {
struct ncp_conn_spec
{
char server[NCP_BINDERY_NAME_LEN];
char user[NCP_BINDERY_NAME_LEN];
uid_t uid;
@@ -74,12 +164,14 @@ struct ncp_conn_spec {
char password[NCP_BINDERY_NAME_LEN];
};
struct ncp_search_seq {
struct ncp_search_seq
{
struct nw_search_sequence s;
int namespace;
};
struct ncp_property_info {
struct ncp_property_info
{
__u8 property_name[16];
__u8 property_flags;
__u8 property_security;
@@ -94,46 +186,47 @@ struct ncp_property_info {
from the list. It was designed after the X Windows init
functions. */
struct ncp_conn *
ncp_initialize(int *argc, char **argv,
int login_necessary, long *err);
ncp_initialize(int *argc, char **argv,
int login_necessary, long *err);
/* You can login as another object by this procedure. As a first use
pserver comes to mind. */
struct ncp_conn *
ncp_initialize_as(int *argc, char **argv,
int login_necessary, int login_type, long *err);
ncp_initialize_as(int *argc, char **argv,
int login_necessary, int login_type, long *err);
/* Open a connection */
struct ncp_conn *
ncp_open(const struct ncp_conn_spec *spec, long *err);
ncp_open(const struct ncp_conn_spec *spec, long *err);
/* Open a connection on an existing mount point */
struct ncp_conn *
ncp_open_mount(const char *mount_point, long *err);
ncp_open_mount(const char *mount_point, long *err);
/* Find a permanent connection that fits the spec, return NULL if
* there is none. */
char *
ncp_find_permanent(const struct ncp_conn_spec *spec);
ncp_find_permanent(const struct ncp_conn_spec *spec);
/* Find the address of a file server */
struct sockaddr_ipx *
ncp_find_fileserver(const char *server_name, long *err);
ncp_find_fileserver(const char *server_name, long *err);
/* Find the address of a server */
struct sockaddr_ipx *
ncp_find_server(const char **server_name, int type, long *err);
ncp_find_server(const char **server_name, int type, long *err);
/* Detach from a permanent connection or destroy a temporary
connection */
long
ncp_close(struct ncp_conn *conn);
ncp_close(struct ncp_conn *conn);
/* like getmntent, get_ncp_conn_ent scans /etc/mtab for usable
connections */
struct ncp_conn_ent {
struct ncp_conn_ent
{
char server[NCP_BINDERY_NAME_LEN];
char user[NCP_BINDERY_NAME_LEN];
uid_t uid;
@@ -141,7 +234,7 @@ struct ncp_conn_ent {
};
struct ncp_conn_ent *
ncp_get_conn_ent(FILE *filep);
ncp_get_conn_ent(FILE * filep);
#define NWCLIENT (".nwclient")
#define NWC_NOPASSWORD ("-")
@@ -149,165 +242,168 @@ ncp_get_conn_ent(FILE *filep);
/* find an appropriate connection */
struct ncp_conn_spec *
ncp_find_conn_spec(const char *server, const char *user, const char *password,
int login_necessary, uid_t uid, long *err);
ncp_find_conn_spec(const char *server, const char *user, const char *password,
int login_necessary, uid_t uid, long *err);
long
ncp_get_file_server_description_strings(struct ncp_conn *conn,
char target[512]);
ncp_get_file_server_description_strings(struct ncp_conn *conn,
char target[512]);
long
ncp_get_file_server_time(struct ncp_conn *conn, time_t *target);
ncp_get_file_server_time(struct ncp_conn *conn, time_t * target);
long
ncp_set_file_server_time(struct ncp_conn *conn, time_t *source);
ncp_set_file_server_time(struct ncp_conn *conn, time_t * source);
struct ncp_file_server_info {
__u8 ServerName[48] __attribute__ ((packed));
__u8 FileServiceVersion __attribute__ ((packed));
__u8 FileServiceSubVersion __attribute__ ((packed));
__u16 MaximumServiceConnections __attribute__ ((packed));
__u16 ConnectionsInUse __attribute__ ((packed));
__u16 NumberMountedVolumes __attribute__ ((packed));
__u8 Revision __attribute__ ((packed));
__u8 SFTLevel __attribute__ ((packed));
__u8 TTSLevel __attribute__ ((packed));
__u16 MaxConnectionsEverUsed __attribute__ ((packed));
__u8 AccountVersion __attribute__ ((packed));
__u8 VAPVersion __attribute__ ((packed));
__u8 QueueVersion __attribute__ ((packed));
__u8 PrintVersion __attribute__ ((packed));
__u8 VirtualConsoleVersion __attribute__ ((packed));
__u8 RestrictionLevel __attribute__ ((packed));
__u8 InternetBridge __attribute__ ((packed));
__u8 Reserved[60] __attribute__ ((packed));
struct ncp_file_server_info
{
__u8 ServerName[48] __attribute__((packed));
__u8 FileServiceVersion __attribute__((packed));
__u8 FileServiceSubVersion __attribute__((packed));
__u16 MaximumServiceConnections __attribute__((packed));
__u16 ConnectionsInUse __attribute__((packed));
__u16 NumberMountedVolumes __attribute__((packed));
__u8 Revision __attribute__((packed));
__u8 SFTLevel __attribute__((packed));
__u8 TTSLevel __attribute__((packed));
__u16 MaxConnectionsEverUsed __attribute__((packed));
__u8 AccountVersion __attribute__((packed));
__u8 VAPVersion __attribute__((packed));
__u8 QueueVersion __attribute__((packed));
__u8 PrintVersion __attribute__((packed));
__u8 VirtualConsoleVersion __attribute__((packed));
__u8 RestrictionLevel __attribute__((packed));
__u8 InternetBridge __attribute__((packed));
__u8 Reserved[60] __attribute__((packed));
};
long
ncp_get_file_server_information(struct ncp_conn *conn,
struct ncp_file_server_info *target);
ncp_get_file_server_information(struct ncp_conn *conn,
struct ncp_file_server_info *target);
long
ncp_get_connlist(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
int *returned_no, __u8 conn_numbers[256]);
ncp_get_connlist(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
int *returned_no, __u8 conn_numbers[256]);
long
ncp_get_stations_logged_info(struct ncp_conn *conn,
__u32 connection,
struct ncp_bindery_object *target,
time_t *login_time);
ncp_get_stations_logged_info(struct ncp_conn *conn,
__u32 connection,
struct ncp_bindery_object *target,
time_t * login_time);
long
ncp_get_internet_address(struct ncp_conn *conn,
__u32 connection,
struct sockaddr_ipx *target,
__u8 *conn_type);
ncp_get_internet_address(struct ncp_conn *conn,
__u32 connection,
struct sockaddr_ipx *target,
__u8 * conn_type);
long
ncp_send_broadcast(struct ncp_conn *conn,
__u8 no_conn, const __u8 *connections,
const char *message);
ncp_send_broadcast(struct ncp_conn *conn,
__u8 no_conn, const __u8 * connections,
const char *message);
long
ncp_get_encryption_key(struct ncp_conn *conn,
char *target);
ncp_get_encryption_key(struct ncp_conn *conn,
char *target);
long
ncp_get_bindery_object_id(struct ncp_conn *conn,
__u16 object_type,
const char *object_name,
struct ncp_bindery_object *target);
long
ncp_get_bindery_object_name(struct ncp_conn *conn,
__u32 object_id,
struct ncp_bindery_object *target);
long
ncp_scan_bindery_object(struct ncp_conn *conn,
__u32 last_id, __u16 object_type, char *search_string,
struct ncp_bindery_object *target);
long
ncp_create_bindery_object(struct ncp_conn *conn,
__u16 object_type,
const char *object_name,
__u8 object_security,
__u8 object_status);
long
ncp_delete_bindery_object(struct ncp_conn *conn,
__u16 object_type,
const char *object_name);
long
ncp_change_object_security(struct ncp_conn *conn,
ncp_get_bindery_object_id(struct ncp_conn *conn,
__u16 object_type,
const char *object_name,
__u8 security);
struct ncp_bindery_object *target);
long
ncp_get_bindery_object_name(struct ncp_conn *conn,
__u32 object_id,
struct ncp_bindery_object *target);
long
ncp_scan_bindery_object(struct ncp_conn *conn,
__u32 last_id, __u16 object_type, char *search_string,
struct ncp_bindery_object *target);
long
ncp_create_bindery_object(struct ncp_conn *conn,
__u16 object_type,
const char *object_name,
__u8 object_security,
__u8 object_status);
long
ncp_delete_bindery_object(struct ncp_conn *conn,
__u16 object_type,
const char *object_name);
struct ncp_station_addr {
__u32 NetWork __attribute__ ((packed));
__u8 Node[6] __attribute__ ((packed));
__u16 Socket __attribute__ ((packed));
long
ncp_change_object_security(struct ncp_conn *conn,
__u16 object_type,
const char *object_name,
__u8 security);
struct ncp_station_addr
{
__u32 NetWork __attribute__((packed));
__u8 Node[6] __attribute__((packed));
__u16 Socket __attribute__((packed));
};
struct ncp_prop_login_control {
__u8 AccountExpireDate[3] __attribute__ ((packed));
__u8 Disabled __attribute__ ((packed));
__u8 PasswordExpireDate[3] __attribute__ ((packed));
__u8 GraceLogins __attribute__ ((packed));
__u16 PasswordExpireInterval __attribute__ ((packed));
__u8 MaxGraceLogins __attribute__ ((packed));
__u8 MinPasswordLength __attribute__ ((packed));
__u16 MaxConnections __attribute__ ((packed));
__u8 ConnectionTimeMask[42] __attribute__ ((packed));
__u8 LastLogin[6] __attribute__ ((packed));
__u8 RestrictionMask __attribute__ ((packed));
__u8 reserved __attribute__ ((packed));
__u32 MaxDiskUsage __attribute__ ((packed));
__u16 BadLoginCount __attribute__ ((packed));
__u32 BadLoginCountDown __attribute__ ((packed));
struct ncp_station_addr LastIntruder __attribute__ ((packed));
};
struct ncp_prop_login_control
{
__u8 AccountExpireDate[3] __attribute__((packed));
__u8 Disabled __attribute__((packed));
__u8 PasswordExpireDate[3] __attribute__((packed));
__u8 GraceLogins __attribute__((packed));
__u16 PasswordExpireInterval __attribute__((packed));
__u8 MaxGraceLogins __attribute__((packed));
__u8 MinPasswordLength __attribute__((packed));
__u16 MaxConnections __attribute__((packed));
__u8 ConnectionTimeMask[42] __attribute__((packed));
__u8 LastLogin[6] __attribute__((packed));
__u8 RestrictionMask __attribute__((packed));
__u8 reserved __attribute__((packed));
__u32 MaxDiskUsage __attribute__((packed));
__u16 BadLoginCount __attribute__((packed));
__u32 BadLoginCountDown __attribute__((packed));
struct ncp_station_addr LastIntruder __attribute__((packed));
};
long
ncp_read_property_value(struct ncp_conn *conn,
int object_type, const char *object_name,
int segment, const char *prop_name,
struct nw_property *target);
ncp_read_property_value(struct ncp_conn *conn,
int object_type, const char *object_name,
int segment, const char *prop_name,
struct nw_property *target);
long
ncp_scan_property(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
__u32 last_id, char *search_string,
struct ncp_property_info *property_info);
ncp_scan_property(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
__u32 last_id, char *search_string,
struct ncp_property_info *property_info);
long
ncp_add_object_to_set(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u16 member_type,
const char *member_name);
ncp_add_object_to_set(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u16 member_type,
const char *member_name);
long
ncp_change_property_security(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u8 property_security);
ncp_change_property_security(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u8 property_security);
long
ncp_create_property(struct ncp_conn *conn,
ncp_create_property(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
const char *property_name,
__u8 property_flags, __u8 property_security);
long
ncp_delete_object_from_set(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u16 member_type,
const char *member_name);
long
ncp_delete_property(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name);
ncp_delete_object_from_set(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u16 member_type,
const char *member_name);
long
ncp_write_property_value(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u8 segment,
struct nw_property *property_value);
ncp_delete_property(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name);
long
ncp_write_property_value(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const char *property_name,
__u8 segment,
struct nw_property *property_value);
/* Bit masks for security flag */
#define NCP_SEC_CHECKSUMMING_REQUESTED (1)
@@ -317,138 +413,138 @@ ncp_write_property_value(struct ncp_conn *conn,
#define NCP_SEC_LIP_DISABLED (128)
long
ncp_get_big_ncp_max_packet_size(struct ncp_conn *conn,
__u16 proposed_max_size,
__u8 proposed_security_flag,
__u16 *accepted_max_size,
__u16 *echo_socket,
__u8 *accepted_security_flag);
ncp_get_big_ncp_max_packet_size(struct ncp_conn *conn,
__u16 proposed_max_size,
__u8 proposed_security_flag,
__u16 * accepted_max_size,
__u16 * echo_socket,
__u8 * accepted_security_flag);
long
ncp_login_encrypted(struct ncp_conn *conn,
const struct ncp_bindery_object *object,
const unsigned char *key,
const unsigned char *passwd);
ncp_login_encrypted(struct ncp_conn *conn,
const struct ncp_bindery_object *object,
const unsigned char *key,
const unsigned char *passwd);
long
ncp_login_unencrypted(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const unsigned char *passwd);
ncp_login_unencrypted(struct ncp_conn *conn,
__u16 object_type, const char *object_name,
const unsigned char *passwd);
long
ncp_change_login_passwd(struct ncp_conn *conn,
const struct ncp_bindery_object *object,
const unsigned char *key,
const unsigned char *oldpasswd,
const unsigned char *newpasswd);
ncp_change_login_passwd(struct ncp_conn *conn,
const struct ncp_bindery_object *object,
const unsigned char *key,
const unsigned char *oldpasswd,
const unsigned char *newpasswd);
#define NCP_GRACE_PERIOD (0xdf)
long
ncp_login_user(struct ncp_conn *conn,
const unsigned char *username,
const unsigned char *password);
ncp_login_user(struct ncp_conn *conn,
const unsigned char *username,
const unsigned char *password);
long
ncp_get_volume_info_with_number(struct ncp_conn *conn, int n,
struct ncp_volume_info *target);
ncp_get_volume_info_with_number(struct ncp_conn *conn, int n,
struct ncp_volume_info *target);
long
ncp_get_volume_number(struct ncp_conn *conn, const char *name,
int *target);
ncp_get_volume_number(struct ncp_conn *conn, const char *name,
int *target);
long
ncp_file_search_init(struct ncp_conn *conn,
int dir_handle, const char *path,
struct ncp_filesearch_info *target);
ncp_file_search_init(struct ncp_conn *conn,
int dir_handle, const char *path,
struct ncp_filesearch_info *target);
long
ncp_file_search_continue(struct ncp_conn *conn,
struct ncp_filesearch_info *fsinfo,
int attributes, const char *path,
struct ncp_file_info *target);
ncp_file_search_continue(struct ncp_conn *conn,
struct ncp_filesearch_info *fsinfo,
int attributes, const char *path,
struct ncp_file_info *target);
long
ncp_get_finfo(struct ncp_conn *conn,
int dir_handle, const char *path, const char *name,
struct ncp_file_info *target);
ncp_get_finfo(struct ncp_conn *conn,
int dir_handle, const char *path, const char *name,
struct ncp_file_info *target);
long
ncp_open_file(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr, int access,
struct ncp_file_info *target);
long
ncp_close_file(struct ncp_conn *conn, const char *file_id);
long
ncp_create_newfile(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr,
struct ncp_file_info *target);
long
ncp_create_file(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr,
struct ncp_file_info *target);
long
ncp_erase_file(struct ncp_conn *conn,
ncp_open_file(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr);
int attr, int access,
struct ncp_file_info *target);
long
ncp_close_file(struct ncp_conn *conn, const char *file_id);
long
ncp_rename_file(struct ncp_conn *conn,
int old_handle, const char *old_path,
int attr,
int new_handle, const char *new_path);
ncp_create_newfile(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr,
struct ncp_file_info *target);
long
ncp_create_directory(struct ncp_conn *conn,
int dir_handle, const char *path,
int inherit_mask);
ncp_create_file(struct ncp_conn *conn,
int dir_handle, const char *path,
int attr,
struct ncp_file_info *target);
long
ncp_delete_directory(struct ncp_conn *conn,
int dir_handle, const char *path);
long
ncp_rename_directory(struct ncp_conn *conn,
int dir_handle,
const char *old_path, const char *new_path);
long
ncp_add_trustee(struct ncp_conn *conn,
ncp_erase_file(struct ncp_conn *conn,
int dir_handle, const char *path,
__u32 object_id, __u8 rights);
int attr);
long
ncp_delete_trustee(struct ncp_conn *conn,
int dir_handle, const char *path, __u32 object_id);
ncp_rename_file(struct ncp_conn *conn,
int old_handle, const char *old_path,
int attr,
int new_handle, const char *new_path);
long
ncp_read(struct ncp_conn *conn, const char *file_id,
off_t offset, size_t count, char *target);
ncp_create_directory(struct ncp_conn *conn,
int dir_handle, const char *path,
int inherit_mask);
long
ncp_write(struct ncp_conn *conn, const char *file_id,
off_t offset, size_t count, const char *source);
ncp_delete_directory(struct ncp_conn *conn,
int dir_handle, const char *path);
long
ncp_copy_file(struct ncp_conn *conn,
const char source_file[6],
const char target_file[6],
__u32 source_offset,
__u32 target_offset,
__u32 count,
__u32 *copied_count);
ncp_rename_directory(struct ncp_conn *conn,
int dir_handle,
const char *old_path, const char *new_path);
long
ncp_obtain_file_or_subdir_info(struct ncp_conn *conn,
__u8 source_ns, __u8 target_ns,
__u16 search_attribs, __u32 rim,
__u8 vol, __u32 dirent, const char *path,
struct nw_info_struct *target);
ncp_add_trustee(struct ncp_conn *conn,
int dir_handle, const char *path,
__u32 object_id, __u8 rights);
long
ncp_delete_trustee(struct ncp_conn *conn,
int dir_handle, const char *path, __u32 object_id);
long
ncp_read(struct ncp_conn *conn, const char *file_id,
off_t offset, size_t count, char *target);
long
ncp_write(struct ncp_conn *conn, const char *file_id,
off_t offset, size_t count, const char *source);
long
ncp_copy_file(struct ncp_conn *conn,
const char source_file[6],
const char target_file[6],
__u32 source_offset,
__u32 target_offset,
__u32 count,
__u32 * copied_count);
long
ncp_obtain_file_or_subdir_info(struct ncp_conn *conn,
__u8 source_ns, __u8 target_ns,
__u16 search_attribs, __u32 rim,
__u8 vol, __u32 dirent, const char *path,
struct nw_info_struct *target);
#define NCP_PERM_READ (0x001)
#define NCP_PERM_WRITE (0x002)
@@ -461,103 +557,103 @@ ncp_obtain_file_or_subdir_info(struct ncp_conn *conn,
#define NCP_PERM_SUPER (0x100)
long
ncp_get_eff_directory_rights(struct ncp_conn *conn,
__u8 source_ns, __u8 target_ns,
__u16 search_attribs,
__u8 vol, __u32 dirent, const char *path,
__u16 *my_effective_rights);
ncp_get_eff_directory_rights(struct ncp_conn *conn,
__u8 source_ns, __u8 target_ns,
__u16 search_attribs,
__u8 vol, __u32 dirent, const char *path,
__u16 * my_effective_rights);
long
ncp_do_lookup(struct ncp_conn *conn,
struct nw_info_struct *dir,
char *path, /* may only be one component */
struct nw_info_struct *target);
ncp_do_lookup(struct ncp_conn *conn,
struct nw_info_struct *dir,
char *path, /* may only be one component */
struct nw_info_struct *target);
long
ncp_modify_file_or_subdir_dos_info(struct ncp_conn *conn,
struct nw_info_struct *file,
__u32 info_mask,
struct nw_modify_dos_info *info);
ncp_modify_file_or_subdir_dos_info(struct ncp_conn *conn,
struct nw_info_struct *file,
__u32 info_mask,
struct nw_modify_dos_info *info);
long
ncp_del_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *dir, char *name);
ncp_del_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *dir, char *name);
long
ncp_open_create_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *dir, char *name,
int open_create_mode,
__u32 create_attributes,
int desired_acc_rights,
struct nw_file_info *target);
ncp_open_create_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *dir, char *name,
int open_create_mode,
__u32 create_attributes,
int desired_acc_rights,
struct nw_file_info *target);
long
ncp_initialize_search(struct ncp_conn *conn,
const struct nw_info_struct *dir,
int namespace,
struct ncp_search_seq *target);
ncp_initialize_search(struct ncp_conn *conn,
const struct nw_info_struct *dir,
int namespace,
struct ncp_search_seq *target);
long
ncp_search_for_file_or_subdir(struct ncp_conn *conn,
struct ncp_search_seq *seq,
struct nw_info_struct *target);
ncp_search_for_file_or_subdir(struct ncp_conn *conn,
struct ncp_search_seq *seq,
struct nw_info_struct *target);
long
ncp_ren_or_mov_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *old_dir, char *old_name,
struct nw_info_struct *new_dir, char *new_name);
ncp_ren_or_mov_file_or_subdir(struct ncp_conn *conn,
struct nw_info_struct *old_dir, char *old_name,
struct nw_info_struct *new_dir, char *new_name);
long
ncp_create_queue_job_and_file(struct ncp_conn *conn,
ncp_create_queue_job_and_file(struct ncp_conn *conn,
__u32 queue_id,
struct queue_job *job);
long
ncp_close_file_and_start_job(struct ncp_conn *conn,
__u32 queue_id,
struct queue_job *job);
long
ncp_close_file_and_start_job(struct ncp_conn *conn,
__u32 queue_id,
struct queue_job *job);
ncp_attach_to_queue(struct ncp_conn *conn,
__u32 queue_id);
long
ncp_attach_to_queue(struct ncp_conn *conn,
__u32 queue_id);
ncp_detach_from_queue(struct ncp_conn *conn,
__u32 queue_id);
long
ncp_detach_from_queue(struct ncp_conn *conn,
__u32 queue_id);
ncp_service_queue_job(struct ncp_conn *conn, __u32 queue_id, __u16 job_type,
struct queue_job *job);
long
ncp_service_queue_job(struct ncp_conn *conn, __u32 queue_id, __u16 job_type,
struct queue_job *job);
ncp_finish_servicing_job(struct ncp_conn *conn, __u32 queue_id,
__u32 job_number, __u32 charge_info);
long
ncp_finish_servicing_job(struct ncp_conn *conn, __u32 queue_id,
__u32 job_number, __u32 charge_info);
ncp_abort_servicing_job(struct ncp_conn *conn, __u32 queue_id,
__u32 job_number);
long
ncp_abort_servicing_job(struct ncp_conn *conn, __u32 queue_id,
__u32 job_number);
ncp_get_broadcast_message(struct ncp_conn *conn, char message[256]);
long
ncp_get_broadcast_message(struct ncp_conn *conn, char message[256]);
long
ncp_dealloc_dir_handle(struct ncp_conn *conn, __u8 dir_handle);
ncp_dealloc_dir_handle(struct ncp_conn *conn, __u8 dir_handle);
#define NCP_ALLOC_PERMANENT (0x0000)
#define NCP_ALLOC_TEMPORARY (0x0001)
#define NCP_ALLOC_SPECIAL (0x0002)
long
ncp_alloc_short_dir_handle(struct ncp_conn *conn,
struct nw_info_struct *dir,
__u16 alloc_mode,
__u8 *target);
ncp_alloc_short_dir_handle(struct ncp_conn *conn,
struct nw_info_struct *dir,
__u16 alloc_mode,
__u8 * target);
long
ncp_get_effective_dir_rights(struct ncp_conn *conn,
struct nw_info_struct *file,
__u16 *target);
ncp_get_effective_dir_rights(struct ncp_conn *conn,
struct nw_info_struct *file,
__u16 * target);
struct ncp_trustee_struct
{
@@ -566,10 +662,10 @@ struct ncp_trustee_struct
};
long
ncp_add_trustee_set(struct ncp_conn *conn,
__u8 volume_number, __u32 dir_entry,
__u16 rights_mask,
int object_count, struct ncp_trustee_struct *rights);
ncp_add_trustee_set(struct ncp_conn *conn,
__u8 volume_number, __u32 dir_entry,
__u16 rights_mask,
int object_count, struct ncp_trustee_struct *rights);
#endif /* _NCPLIB_H */
#endif /* _NCPLIB_H */

2
lib/Makefile
View File

@@ -28,7 +28,7 @@ install:
$(INSTALL_LIB)
ncplib.o: ncplib.c ncplib_err.h
$(CC) $(CFLAGS) -finline-functions -c ncplib.c
$(CC) $(CFLAGS) -c ncplib.c
COM_ERR_CFILES = com_err/com_err.c com_err/error_message.c com_err/et_name.c \
com_err/init_et.c

1145
lib/ncplib.c
View File

File diff suppressed because it is too large Load Diff

154
lib/nwcrypt.c
View File

@@ -1,17 +1,17 @@
/*$*********************************************************
$*
$* This code has been taken from DDJ 11/93, from an
$* article by Pawel Szczerbina.
$*
$* Password encryption routines follow.
$* Converted to C from Barry Nance's Pascal
$* prog published in the March -93 issue of Byte.
$*
$* Adapted to be useable for ncpfs by
$* Volker Lendecke <lendecke@namu01.gwdg.de> in
$* October 1995.
$*
$**********************************************************/
$*
$* This code has been taken from DDJ 11/93, from an
$* article by Pawel Szczerbina.
$*
$* Password encryption routines follow.
$* Converted to C from Barry Nance's Pascal
$* prog published in the March -93 issue of Byte.
$*
$* Adapted to be useable for ncpfs by
$* Volker Lendecke <lendecke@namu01.gwdg.de> in
$* October 1995.
$*
$********************************************************* */
/****************************************************************************
@@ -91,28 +91,28 @@ typedef unsigned char buf8[8];
typedef unsigned char buf4[4];
static unsigned char encrypttable[256] =
{0x7,0x8,0x0,0x8,0x6,0x4,0xE,0x4,0x5,0xC,0x1,0x7,0xB,0xF,0xA,0x8,
0xF,0x8,0xC,0xC,0x9,0x4,0x1,0xE,0x4,0x6,0x2,0x4,0x0,0xA,0xB,0x9,
0x2,0xF,0xB,0x1,0xD,0x2,0x1,0x9,0x5,0xE,0x7,0x0,0x0,0x2,0x6,0x6,
0x0,0x7,0x3,0x8,0x2,0x9,0x3,0xF,0x7,0xF,0xC,0xF,0x6,0x4,0xA,0x0,
0x2,0x3,0xA,0xB,0xD,0x8,0x3,0xA,0x1,0x7,0xC,0xF,0x1,0x8,0x9,0xD,
0x9,0x1,0x9,0x4,0xE,0x4,0xC,0x5,0x5,0xC,0x8,0xB,0x2,0x3,0x9,0xE,
0x7,0x7,0x6,0x9,0xE,0xF,0xC,0x8,0xD,0x1,0xA,0x6,0xE,0xD,0x0,0x7,
0x7,0xA,0x0,0x1,0xF,0x5,0x4,0xB,0x7,0xB,0xE,0xC,0x9,0x5,0xD,0x1,
0xB,0xD,0x1,0x3,0x5,0xD,0xE,0x6,0x3,0x0,0xB,0xB,0xF,0x3,0x6,0x4,
0x9,0xD,0xA,0x3,0x1,0x4,0x9,0x4,0x8,0x3,0xB,0xE,0x5,0x0,0x5,0x2,
0xC,0xB,0xD,0x5,0xD,0x5,0xD,0x2,0xD,0x9,0xA,0xC,0xA,0x0,0xB,0x3,
0x5,0x3,0x6,0x9,0x5,0x1,0xE,0xE,0x0,0xE,0x8,0x2,0xD,0x2,0x2,0x0,
0x4,0xF,0x8,0x5,0x9,0x6,0x8,0x6,0xB,0xA,0xB,0xF,0x0,0x7,0x2,0x8,
0xC,0x7,0x3,0xA,0x1,0x4,0x2,0x5,0xF,0x7,0xA,0xC,0xE,0x5,0x9,0x3,
0xE,0x7,0x1,0x2,0xE,0x1,0xF,0x4,0xA,0x6,0xC,0x6,0xF,0x4,0x3,0x0,
0xC,0x0,0x3,0x6,0xF,0x8,0x7,0xB,0x2,0xD,0xC,0x6,0xA,0xA,0x8,0xD};
{0x7, 0x8, 0x0, 0x8, 0x6, 0x4, 0xE, 0x4, 0x5, 0xC, 0x1, 0x7, 0xB, 0xF, 0xA, 0x8,
0xF, 0x8, 0xC, 0xC, 0x9, 0x4, 0x1, 0xE, 0x4, 0x6, 0x2, 0x4, 0x0, 0xA, 0xB, 0x9,
0x2, 0xF, 0xB, 0x1, 0xD, 0x2, 0x1, 0x9, 0x5, 0xE, 0x7, 0x0, 0x0, 0x2, 0x6, 0x6,
0x0, 0x7, 0x3, 0x8, 0x2, 0x9, 0x3, 0xF, 0x7, 0xF, 0xC, 0xF, 0x6, 0x4, 0xA, 0x0,
0x2, 0x3, 0xA, 0xB, 0xD, 0x8, 0x3, 0xA, 0x1, 0x7, 0xC, 0xF, 0x1, 0x8, 0x9, 0xD,
0x9, 0x1, 0x9, 0x4, 0xE, 0x4, 0xC, 0x5, 0x5, 0xC, 0x8, 0xB, 0x2, 0x3, 0x9, 0xE,
0x7, 0x7, 0x6, 0x9, 0xE, 0xF, 0xC, 0x8, 0xD, 0x1, 0xA, 0x6, 0xE, 0xD, 0x0, 0x7,
0x7, 0xA, 0x0, 0x1, 0xF, 0x5, 0x4, 0xB, 0x7, 0xB, 0xE, 0xC, 0x9, 0x5, 0xD, 0x1,
0xB, 0xD, 0x1, 0x3, 0x5, 0xD, 0xE, 0x6, 0x3, 0x0, 0xB, 0xB, 0xF, 0x3, 0x6, 0x4,
0x9, 0xD, 0xA, 0x3, 0x1, 0x4, 0x9, 0x4, 0x8, 0x3, 0xB, 0xE, 0x5, 0x0, 0x5, 0x2,
0xC, 0xB, 0xD, 0x5, 0xD, 0x5, 0xD, 0x2, 0xD, 0x9, 0xA, 0xC, 0xA, 0x0, 0xB, 0x3,
0x5, 0x3, 0x6, 0x9, 0x5, 0x1, 0xE, 0xE, 0x0, 0xE, 0x8, 0x2, 0xD, 0x2, 0x2, 0x0,
0x4, 0xF, 0x8, 0x5, 0x9, 0x6, 0x8, 0x6, 0xB, 0xA, 0xB, 0xF, 0x0, 0x7, 0x2, 0x8,
0xC, 0x7, 0x3, 0xA, 0x1, 0x4, 0x2, 0x5, 0xF, 0x7, 0xA, 0xC, 0xE, 0x5, 0x9, 0x3,
0xE, 0x7, 0x1, 0x2, 0xE, 0x1, 0xF, 0x4, 0xA, 0x6, 0xC, 0x6, 0xF, 0x4, 0x3, 0x0,
0xC, 0x0, 0x3, 0x6, 0xF, 0x8, 0x7, 0xB, 0x2, 0xD, 0xC, 0x6, 0xA, 0xA, 0x8, 0xD};
static buf32 encryptkeys =
{0x48,0x93,0x46,0x67,0x98,0x3D,0xE6,0x8D,
0xB7,0x10,0x7A,0x26,0x5A,0xB9,0xB1,0x35,
0x6B,0x0F,0xD5,0x70,0xAE,0xFB,0xAD,0x11,
0xF4,0x47,0xDC,0xA7,0xEC,0xCF,0x50,0xC0};
static buf32 encryptkeys =
{0x48, 0x93, 0x46, 0x67, 0x98, 0x3D, 0xE6, 0x8D,
0xB7, 0x10, 0x7A, 0x26, 0x5A, 0xB9, 0xB1, 0x35,
0x6B, 0x0F, 0xD5, 0x70, 0xAE, 0xFB, 0xAD, 0x11,
0xF4, 0x47, 0xDC, 0xA7, 0xEC, 0xCF, 0x50, 0xC0};
static void
@@ -128,15 +128,16 @@ shuffle1(buf32 temp, unsigned char *target)
{
for (s = 0; s <= 31; ++s)
{
b3 = (temp[s]+b4) ^ (temp[(s+b4)&31] - encryptkeys[s]);
b3 = (temp[s] + b4) ^ (temp[(s + b4) & 31] - encryptkeys[s]);
b4 = b4 + b3;
temp[s] = b3;
}
}
for (i = 0; i <= 15; ++i) {
target[i] = encrypttable[temp[ 2*i ]]
| (encrypttable[temp[ 2*i + 1]] << 4);
for (i = 0; i <= 15; ++i)
{
target[i] = encrypttable[temp[2 * i]]
| (encrypttable[temp[2 * i + 1]] << 4);
}
}
@@ -148,12 +149,14 @@ shuffle(const unsigned char *lon, const unsigned char *buf, int buflen,
int b2, d, s;
buf32 temp;
while ( (buflen > 0)
&& (buf[buflen - 1] == 0)) {
while ((buflen > 0)
&& (buf[buflen - 1] == 0))
{
buflen = buflen - 1;
}
for (s = 0; s < 32; s++) {
for (s = 0; s < 32; s++)
{
temp[s] = 0;
}
@@ -176,17 +179,17 @@ shuffle(const unsigned char *lon, const unsigned char *buf, int buflen,
{
b2 = d;
temp[s] = temp[s] ^ encryptkeys[s];
} else {
} else
{
temp[s] = temp[s] ^ buf[b2];
b2 = b2 + 1;
}
}
}
for (s = 0; s <= 31; ++s)
temp[s] = temp[s] ^ lon[s & 3];
shuffle1(temp,target);
shuffle1(temp, target);
}
@@ -198,7 +201,7 @@ nw_encrypt(const unsigned char *fra,
buf32 k;
int s;
shuffle(&(fra[0]), buf, 16, &(k[ 0]));
shuffle(&(fra[0]), buf, 16, &(k[0]));
shuffle(&(fra[4]), buf, 16, &(k[16]));
for (s = 0; s <= 15; ++s)
@@ -219,16 +222,17 @@ nw_encrypt(const unsigned char *fra,
/* server side (mars etc.) should:
* store the *encrypted* password internally (output from shuffle)
* verify if nw_encrypt(cryptkey from GetCryptKey, old stored password)
== cryptkey in EncryptedChangePassword request buffer (this means
old password was correct)
== cryptkey in EncryptedChangePassword request buffer (this means
old password was correct)
* decrypt new password in request buffer using (yet to write) inverse of
newpassencrypt with old stored password as parameter
newpassencrypt with old stored password as parameter
* compute the length of the unencrypted new password as len ^ (first byte of
old internal password) ^ (second byte of old internal password)
old internal password) ^ (second byte of old internal password)
*/
static char
newshuffle[256+16] = {
static char
newshuffle[256 + 16] =
{
0x0f, 0x08, 0x05, 0x07, 0x0c, 0x02, 0x0e, 0x09,
0x00, 0x01, 0x06, 0x0d, 0x03, 0x04, 0x0b, 0x0a,
0x02, 0x0c, 0x0e, 0x06, 0x0f, 0x00, 0x01, 0x08,
@@ -279,17 +283,17 @@ newshuffle[256+16] = {
* - Shuffle (aus nwcrypt.c) altes passwort nach old (16 bytes)
* - shuffle neues passwort nach new (16 bytes)
* - nwpassencrypt (diese Funktion) zweimal aufrufen fuer je 8 bytes:
* nwpassencrypt(old+0, new+0, out+0)
* nwpassencrypt(old+8, new+8, out+8)
* nwpassencrypt(old+0, new+0, out+0)
* nwpassencrypt(old+8, new+8, out+8)
* - NCP-Buffer aufbauen:
* 2 byte Laenge im Hi-Lo-Format
* 1 byte Funktion (0x4b)
* 8 byte (nwcrypt Ergebnis analog login/verify password)
* 2 byte Objecttype
* 1 byte Objectname-Laenge
* n byte Objectname
* 1 byte (Laenge des eingegebenen neuen Passworts ^ old[0] ^ old[1])&0x7f|0x40
* 16 byte (Ergebnis dieser Funktion doppelt aufgerufen, s.o.)
* 2 byte Laenge im Hi-Lo-Format
* 1 byte Funktion (0x4b)
* 8 byte (nwcrypt Ergebnis analog login/verify password)
* 2 byte Objecttype
* 1 byte Objectname-Laenge
* n byte Objectname
* 1 byte (Laenge des eingegebenen neuen Passworts ^ old[0] ^ old[1])&0x7f|0x40
* 16 byte (Ergebnis dieser Funktion doppelt aufgerufen, s.o.)
*/
/*
@@ -308,31 +312,31 @@ newpassencrypt(char *old, char *new, char *out)
memcpy(copy, new, 8);
for (i=0; i<16; i++)
for (i = 0; i < 16; i++)
{
for (di=0, ax=0, p=old; di<8; di++, ax+=0x20, p++)
for (di = 0, ax = 0, p = old; di < 8; di++, ax += 0x20, p++)
{
cl=newshuffle[(((copy[di]^*p)>>4)&0x0f)+ax+0x10]<<4;
dl=newshuffle[((copy[di]^*p)&0xf)+ax];
copy[di]=cl|dl;
cl = newshuffle[(((copy[di] ^ *p) >> 4) & 0x0f) + ax + 0x10] << 4;
dl = newshuffle[((copy[di] ^ *p) & 0xf) + ax];
copy[di] = cl | dl;
}
ch=old[7];
for (bx=old+7; bx>old; bx--)
ch = old[7];
for (bx = old + 7; bx > old; bx--)
{
*bx=((bx[-1]>>4)&0x0f)|((*bx)<<4);
*bx = ((bx[-1] >> 4) & 0x0f) | ((*bx) << 4);
}
*old=((ch>>4)&0x0f)|(*old)<<4;
*old = ((ch >> 4) & 0x0f) | (*old) << 4;
memset(out, '\0', 8);
for (di=0; di<16; di++)
for (di = 0; di < 16; di++)
{
if (newshuffle[di+0x100]&1)
ch=((copy[newshuffle[di+0x100]/2]>>4)&0x0f);
if (newshuffle[di + 0x100] & 1)
ch = ((copy[newshuffle[di + 0x100] / 2] >> 4) & 0x0f);
else
ch=copy[newshuffle[di+0x100]/2]&0x0f;
out[di/2]|=((di&1) ? ch<<4 : ch);
ch = copy[newshuffle[di + 0x100] / 2] & 0x0f;
out[di / 2] |= ((di & 1) ? ch << 4 : ch);
}
memcpy(copy, out, 8);
}

15
man/nwpasswd.1
View File

@@ -1,4 +1,4 @@
.TH NWPASSWD 1 06/22/1996 nwpasswd nwpasswd
.TH NWPASSWD 1 01/16/1997 nwpasswd nwpasswd
.SH NAME
nwpasswd \- Change a user's password
.SH SYNOPSIS
@@ -11,6 +11,9 @@ nwpasswd \- Change a user's password
] [
.B -U
.I user name
] [
.B -O
.I object name
]
.B -t
.I object type
@@ -43,6 +46,16 @@ is the name of the server you want to use.
is the name of the bindery object whose password is to be changed.
.RE
.B -O
.I object name
.RS 3
If you have supervisor privileges, you can change other users'
passwords. With
.B -O
you can tell nwpasswd the name of the user whose password should be
changed.
.RE
.B -t
.I object type
.RS 3

100
man/nwvolinfo.1 Normal file
View File

@@ -0,0 +1,100 @@
.TH NWVOLINFO 8 7/9/1996 nwvolinfo nwvolinfo
.SH NAME
nwvolinfo \- Diplay info on NetWare Volumes
.SH SYNOPSIS
.B nwvolinfo
[
.B -h
] [
.B -S
.I server
] [
.B -U
.I user name
] [
.B -P
.I password
|
.B -n
] [
.B -C
] [
.B -v
.I volume
] [
.B -N
]
.SH DESCRIPTION
.B nwvolinfo
displays information on a NetWare Server Volume.
.B nwvolinfo
looks up the file
.I $HOME/.nwclient
to find a file server, a user name and possibly a password. See
nwclient(5) for more information. Please note that the access
permissions of $HOME/.nwclient MUST be 600 for security reasons.
.SH OPTIONS
.B -h
.RS 3
.B -h
is used to print out a short help text.
.RE
.B -S
.I server
.RS 3
.B server
is the name of the server you want to use.
.RE
.B -U
.I user
.RS 3
.B user
is the user name to use for login.
.RE
.B -P
.I password
.RS 3
.B password
is the password to use for login. If neither
.B -n
nor
.B -P
are given, and the user has no open connection to the server, nwvolinfo
prompts for a password.
.RE
.B -n
.RS 3
.B -n
should be given if no password is required for the login.
.RE
.B -C
.RS 3
By default, passwords are converted to uppercase before they are sent
to the server, because most servers require this. You can turn off
this conversion by
.B -C.
.RE
.B -v
.I volume
.RS 3
The volume name to be used. Defaults to 'SYS'.
.RE
.B -N
.RS 3
Display the information in numeric-only format for use in a pipe.
.RE
.SH AUTHORS
nwvolinfo was written by Jacek Stepniewski <cunio@gazeta.pl> based on
utilities by Volker Lendecke.

8
ncpfs-2.0.8.lsm → ncpfs-2.0.9.lsm
View File

@@ -1,7 +1,7 @@
Begin3
Title: ncpfs
Version: 2.0.8
Entered-date: 10. December 1996
Version: 2.0.9
Entered-date: 16. February 1997
Description: With ncpfs you can mount volumes of your netware
server under Linux. You can also print to netware
print queues and spool netware print queues to the
@@ -13,7 +13,7 @@ Author: lendecke@namu01.Num.Math.Uni-Goettingen.de (Volker Lendecke)
Maintained-by: lendecke@namu01.Num.Math.Uni-Goettingen.de (Volker Lendecke)
Primary-site: ftp.gwdg.de:/pub/linux/misc/ncpfs
Alternate-site: sunsite.unc.edu:/pub/Linux/system/Filesystems/ncpfs
~156k ncpfs-2.0.8.tgz
~ 1k ncpfs-2.0.8.lsm
~156k ncpfs-2.0.9.tgz
~ 1k ncpfs-2.0.9.lsm
Copying-policy: GPL
End

13
patches/README Normal file
View File

@@ -0,0 +1,13 @@
To apply the patches, cd into the appropriate kernel source directory
and do:
patch -p1 < patch-file
lockup-2.0.28.diff:
An *extremely* dirty fix to the lockup bug mentioned in the BUGS
file. Please only apply it if you experience the problem. Should apply
to 2.0.28 and above in the 2.0.x series. NOT TESTED with 2.1.x.
linux-2.1.26.diff:
Little fix to make ncpfs work with 2.1.26. Sent to Linus.

35
patches/linux-2.1.26.diff Normal file
View File

@@ -0,0 +1,35 @@
--- 2.1.26/fs/ncpfs/sock.c Sun Jan 26 11:07:44 1997
+++ 2.1.26-patched/fs/ncpfs/sock.c Sun Feb 16 17:05:13 1997
@@ -24,6 +24,7 @@
#include <linux/ncp.h>
#include <linux/ncp_fs.h>
#include <linux/ncp_fs_sb.h>
+#include <linux/poll.h>
#include <net/sock.h>
@@ -343,7 +344,6 @@
char *start = server->packet;
poll_table wait_table;
struct poll_table_entry entry;
- int (*select) (struct inode *, poll_table *);
int init_timeout, max_timeout;
int timeout;
int retrans;
@@ -362,7 +362,6 @@
file = server->ncp_filp;
inode = file->f_inode;
- select = file->f_op->poll;
sock = &inode->u.socket_i;
if (!sock)
{
@@ -418,7 +417,7 @@
wait_table.nr = 0;
wait_table.entry = &entry;
current->state = TASK_INTERRUPTIBLE;
- if (!select(inode, &wait_table))
+ if (!(file->f_op->poll(file, &wait_table) & POLLIN))
{
if (timeout > max_timeout)
{

44
patches/lockup-2.0.28.diff Normal file
View File

@@ -0,0 +1,44 @@
diff -urN 2.0.11/fs/ncpfs/sock.c linux/fs/ncpfs/sock.c
--- 2.0.28/fs/ncpfs/sock.c Fri Jul 12 08:14:53 1996
+++ linux/fs/ncpfs/sock.c Thu Aug 8 19:27:26 1996
@@ -55,7 +55,8 @@
{
struct iovec iov;
struct msghdr msg;
-
+ int result;
+
iov.iov_base = (void *)buff;
iov.iov_len = len;
@@ -65,7 +66,29 @@
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
- return sock->ops->sendmsg(sock, &msg, len, nonblock, flags);
+ result = sock->ops->sendmsg(sock, &msg, len, 1, flags);
+
+ if ((result != -EAGAIN) || (nonblock != 0))
+ {
+ return result;
+ }
+
+ /* The following is probably one of the worst sins you can do
+ to a multitasking kernel: active polling. But when you call
+ ipx_sendmsg with nonblock==0, then it will block forever
+ from time to time. I really do not know why. To work around
+ this, I try to send the packet with nonblock=1 and retry
+ it. */
+
+ do {
+ /* Before retrying, give others a chance */
+ current->state = TASK_INTERRUPTIBLE;
+ current->timeout = jiffies + HZ/10;
+ schedule();
+ result = sock->ops->sendmsg(sock, &msg, len, 1, flags);
+ } while (result == -EAGAIN);
+
+ return result;
}

702
sutil/ncplib.c
View File

File diff suppressed because it is too large Load Diff

84
sutil/ncplib.h
View File

@@ -24,6 +24,90 @@
#define memzero(object) memset(&(object), 0, sizeof(object))
#endif
typedef __u8 byte;
typedef __u16 word;
typedef __u32 dword;
#define BVAL(buf,pos) (((__u8 *)(buf))[pos])
#define PVAL(buf,pos) ((unsigned)BVAL(buf,pos))
#define BSET(buf,pos,val) (BVAL(buf,pos) = (val))
static inline word
WVAL_HL(__u8 *buf, int pos)
{
return PVAL(buf,pos)<<8 | PVAL(buf, pos+1);
}
static inline dword
DVAL_HL(__u8 *buf, int pos)
{
return WVAL_HL(buf, pos)<<16 | WVAL_HL(buf, pos+2);
}
static inline void
WSET_HL(__u8 *buf, int pos, word val)
{
BSET(buf,pos,val>>8);
BSET(buf,pos+1, val & 0xff);
}
static inline void
DSET_HL(__u8 *buf, int pos, dword val)
{
WSET_HL(buf, pos, val >>16);
WSET_HL(buf, pos+2, val & 0xffff);
}
/* we know that the 386 can handle misalignment and has the "right"
byteorder */
#if defined(__i386__)
static inline word
WVAL_LH(__u8 *buf, int pos)
{
return *((word *)(buf+pos));
}
static inline dword
DVAL_LH(__u8 *buf, int pos)
{
return *((dword *)(buf+pos));
}
static inline void
WSET_LH(__u8 *buf, int pos, word val)
{
*((word *)(buf+pos)) = val;
}
static inline void
DSET_LH(__u8 *buf, int pos, dword val)
{
*((dword *)(buf+pos)) = val;
}
#else
static inline word
WVAL_LH(__u8 *buf, int pos)
{
return PVAL(buf,pos) | PVAL(buf, pos+1)<<8;
}
static inline dword
DVAL_LH(__u8 *buf, int pos)
{
return WVAL_LH(buf, pos) | WVAL_LH(buf, pos+2) << 16;
}
static inline void
WSET_LH(__u8 *buf, int pos, word val)
{
BSET(buf,pos,val & 0xff);
BSET(buf,pos+1, val >> 8);
}
static inline void
DSET_LH(__u8 *buf, int pos, dword val)
{
WSET_LH(buf, pos, val & 0xffff);
WSET_LH(buf, pos+2, val >> 16);
}
#endif
void
str_upper(char *name);

434
sutil/ncpmount.c
View File

@@ -26,7 +26,7 @@
#include <netdb.h>
#include <sys/stat.h>
#include <sys/types.h>
/* #include <sys/wait.h> */ /* generates a warning here */
/* #include <sys/wait.h> *//* generates a warning here */
extern pid_t waitpid(pid_t, int *, int);
#include <sys/errno.h>
#include <sys/time.h>
@@ -61,8 +61,8 @@ load_ncpfs(void)
FILE *ffs;
char s[1024];
char *p, *p1;
pid_t pid;
int status;
pid_t pid;
int status;
/* Check if ncpfs is in the kernel */
ffs = fopen("/proc/filesystems", "r");
@@ -72,9 +72,8 @@ load_ncpfs(void)
perror("Error: \"/proc/filesystems\" could not be read:");
return -1;
}
p = NULL;
while (! feof(ffs))
while (!feof(ffs))
{
p1 = fgets(s, sizeof(s), ffs);
if (p1)
@@ -92,84 +91,79 @@ load_ncpfs(void)
{
return 0;
}
/* system() function without signal handling, from Stevens */
/* system() function without signal handling, from Stevens */
if ((pid = fork()) < 0)
if ((pid = fork()) < 0)
{
return 1;
}
else if (pid == 0)
return 1;
} else if (pid == 0)
{
/* child */
execl("/sbin/modprobe", "modprobe", "ncpfs", NULL);
_exit(127); /* execl error */
}
else
/* child */
execl("/sbin/modprobe", "modprobe", "ncpfs", NULL);
_exit(127); /* execl error */
} else
{
/* parent */
while (waitpid(pid, &status, 0) < 0)
/* parent */
while (waitpid(pid, &status, 0) < 0)
{
if (errno != EINTR)
if (errno != EINTR)
{
status = -1;
break;
}
}
}
return status;
status = -1;
break;
}
}
}
return status;
}
#endif /* HAVE_KERNELD */
#endif /* HAVE_KERNELD */
/* Check whether user is allowed to mount on the specified mount point */
static int
mount_ok(struct stat *st)
{
if (!S_ISDIR(st->st_mode))
{
errno = ENOTDIR;
return -1;
}
if ( (getuid() != 0)
&& ( (getuid() != st->st_uid)
|| ((st->st_mode & S_IRWXU) != S_IRWXU)))
{
errno = EPERM;
return -1;
}
return 0;
if (!S_ISDIR(st->st_mode))
{
errno = ENOTDIR;
return -1;
}
if ((getuid() != 0)
&& ((getuid() != st->st_uid)
|| ((st->st_mode & S_IRWXU) != S_IRWXU)))
{
errno = EPERM;
return -1;
}
return 0;
}
int
int
main(int argc, char *argv[])
{
struct ncp_mount_data data;
struct stat st;
struct ncp_mount_data data;
struct stat st;
char mount_name[256];
int fd, result;
int fd, result;
struct sockaddr_ipx addr;
struct sockaddr_ipx *server_addr;
int addrlen;
int upcase_password;
int upcase_password;
long err;
int um;
int um;
unsigned int flags;
char mount_point[MAXPATHLEN];
struct mntent ment;
FILE *mtab;
char mount_point[MAXPATHLEN];
struct mntent ment;
FILE *mtab;
char *tmp_mount;
char *server = NULL;
char *user = NULL;
char *server = NULL;
char *user = NULL;
char *password = NULL;
struct ncp_conn_spec *spec;
@@ -179,36 +173,36 @@ main(int argc, char *argv[])
int opt;
progname = argv[0];
progname = argv[0];
memzero(data); memzero(spec);
memzero(data);
memzero(spec);
if (geteuid() != 0)
{
fprintf(stderr, "%s must be installed suid root\n", progname);
exit(1);
}
data.uid = getuid();
data.gid = getgid();
um = umask(0);
umask(um);
data.file_mode = (S_IRWXU|S_IRWXG|S_IRWXO) & ~um;
data.dir_mode = 0;
data.flags |= NCP_MOUNT_SOFT;
fprintf(stderr, "%s must be installed suid root\n", progname);
exit(1);
}
data.uid = getuid();
data.gid = getgid();
um = umask(0);
umask(um);
data.file_mode = (S_IRWXU | S_IRWXG | S_IRWXO) & ~um;
data.dir_mode = 0;
data.flags |= NCP_MOUNT_SOFT;
data.time_out = 60;
data.retry_count = 5;
upcase_password = 1;
while ((opt = getopt (argc, argv, "CS:U:c:u:g:f:d:P:nh?vV:t:r:"))
while ((opt = getopt(argc, argv, "CS:U:c:u:g:f:d:P:nh?vV:t:r:"))
!= EOF)
{
switch (opt)
switch (opt)
{
case 'C':
upcase_password = 0;
break;
case 'C':
upcase_password = 0;
break;
case 'S':
if (strlen(optarg) >= sizeof(spec->server))
{
@@ -218,80 +212,77 @@ main(int argc, char *argv[])
}
server = optarg;
break;
case 'U':
if (strlen(optarg) >= sizeof(spec->user))
case 'U':
if (strlen(optarg) >= sizeof(spec->user))
{
fprintf(stderr, "Username too long: %s\n",
optarg);
return 1;
}
fprintf(stderr, "Username too long: %s\n",
optarg);
return 1;
}
user = optarg;
break;
case 'c':
if (isdigit(optarg[0]))
case 'c':
if (isdigit(optarg[0]))
{
conn_uid = atoi(optarg);
}
else
} else
{
struct passwd *pwd = getpwnam(optarg);
if (pwd == NULL)
struct passwd *pwd = getpwnam(optarg);
if (pwd == NULL)
{
fprintf(stderr, "Unknown user: %s\n",
optarg);
return 1;
}
conn_uid = pwd->pw_uid;
}
break;
case 'u':
if (isdigit(optarg[0]))
fprintf(stderr, "Unknown user: %s\n",
optarg);
return 1;
}
conn_uid = pwd->pw_uid;
}
break;
case 'u':
if (isdigit(optarg[0]))
{
data.uid = atoi(optarg);
}
else
} else
{
struct passwd *pwd = getpwnam(optarg);
if (pwd == NULL)
struct passwd *pwd = getpwnam(optarg);
if (pwd == NULL)
{
fprintf(stderr, "Unknown user: %s\n",
optarg);
return 1;
}
data.uid = pwd->pw_uid;
}
break;
case 'g':
if (isdigit(optarg[0]))
fprintf(stderr, "Unknown user: %s\n",
optarg);
return 1;
}
data.uid = pwd->pw_uid;
}
break;
case 'g':
if (isdigit(optarg[0]))
{
data.gid = atoi(optarg);
}
else
data.gid = atoi(optarg);
} else
{
struct group *grp = getgrnam(optarg);
if (grp == NULL)
struct group *grp = getgrnam(optarg);
if (grp == NULL)
{
fprintf(stderr, "Unknown group: %s\n",
optarg);
return 1;
}
data.gid = grp->gr_gid;
}
break;
case 'f':
data.file_mode = strtol(optarg, NULL, 8);
break;
case 'd':
data.dir_mode = strtol(optarg, NULL, 8);
break;
case 'P':
fprintf(stderr, "Unknown group: %s\n",
optarg);
return 1;
}
data.gid = grp->gr_gid;
}
break;
case 'f':
data.file_mode = strtol(optarg, NULL, 8);
break;
case 'd':
data.dir_mode = strtol(optarg, NULL, 8);
break;
case 'P':
if (strlen(optarg) >= sizeof(spec->password))
{
printf("password too long\n");
exit(1);
}
password = optarg;
break;
break;
case 'V':
if (strlen(optarg) >= sizeof(data.mounted_vol))
{
@@ -300,9 +291,9 @@ main(int argc, char *argv[])
}
strcpy(data.mounted_vol, optarg);
break;
case 'n':
case 'n':
password = "";
break;
break;
case 't':
data.time_out = atoi(optarg);
break;
@@ -316,46 +307,41 @@ main(int argc, char *argv[])
case 'v':
fprintf(stderr, "ncpfs version %s\n", NCPFS_VERSION);
exit(1);
default:
default:
usage();
return -1;
}
}
return -1;
}
}
if ((spec = ncp_find_conn_spec(server,user,password,1, data.uid, &err))
if ((spec = ncp_find_conn_spec(server, user, password, 1, data.uid, &err))
== NULL)
{
com_err(progname, err, "in find_conn_spec");
exit(1);
}
if (upcase_password != 0)
{
str_upper(spec->password);
}
if (optind != argc-1)
if (optind != argc - 1)
{
usage();
return -1;
}
realpath(argv[optind], mount_point);
if (stat(mount_point, &st) == -1)
if (stat(mount_point, &st) == -1)
{
fprintf(stderr, "could not find mount point %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
if (mount_ok(&st) != 0)
fprintf(stderr, "could not find mount point %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
if (mount_ok(&st) != 0)
{
fprintf(stderr, "cannot to mount on %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
fprintf(stderr, "cannot to mount on %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
#ifndef HAVE_KERNELD
/* Check if the ncpfs filesystem is in the kernel. If not, attempt
* to load the ncpfs module */
@@ -366,21 +352,20 @@ main(int argc, char *argv[])
}
#endif
data.version = NCP_MOUNT_VERSION;
data.mounted_uid = conn_uid;
data.version = NCP_MOUNT_VERSION;
data.mounted_uid = conn_uid;
memcpy(data.server_name, spec->server, sizeof(data.server_name));
if (data.dir_mode == 0)
if (data.dir_mode == 0)
{
data.dir_mode = data.file_mode;
if ((data.dir_mode & S_IRUSR) != 0)
data.dir_mode |= S_IXUSR;
if ((data.dir_mode & S_IRGRP) != 0)
data.dir_mode |= S_IXGRP;
if ((data.dir_mode & S_IROTH) != 0)
data.dir_mode |= S_IXOTH;
}
data.dir_mode = data.file_mode;
if ((data.dir_mode & S_IRUSR) != 0)
data.dir_mode |= S_IXUSR;
if ((data.dir_mode & S_IRGRP) != 0)
data.dir_mode |= S_IXGRP;
if ((data.dir_mode & S_IROTH) != 0)
data.dir_mode |= S_IXOTH;
}
if ((tmp_mount = ncp_find_permanent(spec)) != NULL)
{
@@ -390,7 +375,6 @@ main(int argc, char *argv[])
tmp_mount);
exit(1);
}
if ((server_addr = ncp_find_fileserver(spec->server, &err)) == NULL)
{
com_err("ncpmount", err, "when trying to find %s",
@@ -399,13 +383,12 @@ main(int argc, char *argv[])
}
data.serv_addr = *server_addr;
data.ncp_fd = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
data.ncp_fd = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
if (data.ncp_fd == -1)
{
com_err("ncpmount", err, "opening ncp_socket");
exit(1);
}
data.wdog_fd = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
if (data.wdog_fd == -1)
{
@@ -413,11 +396,10 @@ main(int argc, char *argv[])
strerror(errno));
exit(1);
}
memzero(addr);
addr.sipx_type = NCP_PTYPE;
if (bind(data.ncp_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
if (bind(data.ncp_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
{
fprintf(stderr, "\nbind: %s\n",
strerror(errno));
@@ -427,25 +409,23 @@ main(int argc, char *argv[])
"and try again after waiting a minute.\n\n");
exit(1);
}
addrlen = sizeof(addr);
if (getsockname(data.ncp_fd, (struct sockaddr *)&addr, &addrlen)==-1)
if (getsockname(data.ncp_fd, (struct sockaddr *) &addr, &addrlen) == -1)
{
perror("getsockname ncp socket");
close(data.ncp_fd); close(data.wdog_fd);
close(data.ncp_fd);
close(data.wdog_fd);
exit(1);
}
addr.sipx_port = htons(ntohs(addr.sipx_port) + 1);
if (bind(data.wdog_fd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
if (bind(data.wdog_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
{
fprintf(stderr, "bind(wdog_sock, ): %s\n",
strerror(errno));
exit(1);
}
#if NCP_MOUNT_VERSION>1
data.message_fd = socket(AF_IPX, SOCK_DGRAM, PF_IPX);
@@ -455,16 +435,14 @@ main(int argc, char *argv[])
strerror(errno));
exit(1);
}
addr.sipx_port = htons(ntohs(addr.sipx_port) + 1);
if (bind(data.message_fd, (struct sockaddr *)&addr,sizeof(addr)) == -1)
if (bind(data.message_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1)
{
fprintf(stderr, "bind(message_sock, ): %s\n",
strerror(errno));
exit(1);
}
if (strlen(mount_point) < sizeof(data.mount_point))
{
strcpy(data.mount_point, mount_point);
@@ -477,26 +455,24 @@ main(int argc, char *argv[])
strcat(mount_name, "/");
strcat(mount_name, spec->user);
result = mount(mount_name, mount_point, "ncpfs", flags, (char *)&data);
result = mount(mount_name, mount_point, "ncpfs", flags, (char *) &data);
if (result < 0)
{
printf("mount failed\n");
exit(1);
}
if ((conn = ncp_open_mount(mount_point, &err)) == NULL)
{
com_err("ncpmount", err, "attempt to open mount point");
umount(mount_point);
exit(1);
}
if ((err = ncp_login_user(conn, spec->user, spec->password)) != 0)
{
struct nw_property p;
struct ncp_prop_login_control *l
= (struct ncp_prop_login_control *)&p;
= (struct ncp_prop_login_control *) &p;
if (conn->completion != NCP_GRACE_PERIOD)
{
@@ -506,7 +482,6 @@ main(int argc, char *argv[])
umount(mount_point);
exit(1);
}
fprintf(stderr, "Your password has expired\n");
if ((err = ncp_read_property_value(conn, NCP_BINDERY_USER,
@@ -517,7 +492,6 @@ main(int argc, char *argv[])
l->GraceLogins);
}
}
if ((err = ioctl(conn->mount_fid, NCP_IOC_CONN_LOGGED_IN, NULL)) != 0)
{
com_err("ncpmount", err, "in logged_indication");
@@ -527,78 +501,76 @@ main(int argc, char *argv[])
}
ncp_close(conn);
ment.mnt_fsname = mount_name;
ment.mnt_dir = mount_point;
ment.mnt_type = "ncpfs";
ment.mnt_opts = "rw";
ment.mnt_freq = 0;
ment.mnt_passno= 0;
ment.mnt_fsname = mount_name;
ment.mnt_dir = mount_point;
ment.mnt_type = "ncpfs";
ment.mnt_opts = "rw";
ment.mnt_freq = 0;
ment.mnt_passno = 0;
if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1)
{
fprintf(stderr, "Can't get "MOUNTED"~ lock file");
exit(1);
}
close(fd);
if ((mtab = setmntent(MOUNTED, "a+")) == NULL)
{
fprintf(stderr, "Can't open " MOUNTED);
exit(1);
}
if ((fd = open(MOUNTED "~", O_RDWR | O_CREAT | O_EXCL, 0600)) == -1)
{
fprintf(stderr, "Can't get " MOUNTED "~ lock file");
exit(1);
}
close(fd);
if (addmntent(mtab, &ment) == 1)
{
fprintf(stderr, "Can't write mount entry");
exit(1);
}
if (fchmod(fileno(mtab), 0644) == -1)
{
fprintf(stderr, "Can't set perms on "MOUNTED);
exit(1);
}
endmntent(mtab);
if (unlink(MOUNTED"~") == -1)
{
fprintf(stderr, "Can't remove "MOUNTED"~");
exit(1);
}
if ((mtab = setmntent(MOUNTED, "a+")) == NULL)
{
fprintf(stderr, "Can't open " MOUNTED);
exit(1);
}
if (addmntent(mtab, &ment) == 1)
{
fprintf(stderr, "Can't write mount entry");
exit(1);
}
if (fchmod(fileno(mtab), 0644) == -1)
{
fprintf(stderr, "Can't set perms on " MOUNTED);
exit(1);
}
endmntent(mtab);
if (unlink(MOUNTED "~") == -1)
{
fprintf(stderr, "Can't remove " MOUNTED "~");
exit(1);
}
return 0;
}
}
static void
usage(void)
{
printf("usage: %s [options] mount-point\n", progname);
printf("Try `%s -h' for more information\n", progname);
printf("Try `%s -h' for more information\n", progname);
}
static void
help(void)
{
printf("\n");
printf("usage: %s [options] mount-point\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] mount-point\n", progname);
printf("\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-U username Username sent to server\n"
"-V volume Volume to mount, for NFS re-export\n"
"-u uid uid the mounted files get\n"
"-g gid gid the mounted files get\n"
"-f mode permission the files get (octal notation)\n"
"-d mode permission the dirs get (octal notation)\n"
"-u uid uid the mounted files get\n"
"-g gid gid the mounted files get\n"
"-f mode permission the files get (octal notation)\n"
"-d mode permission the dirs get (octal notation)\n"
"-c uid uid to identify the connection to mount on\n"
" Only makes sense for root\n"
"-t time_out Waiting time (in 1/100s) to wait for\n"
" an answer from the server. Default: 60\n"
"-r retry_count Number of retry attempts. Default: 5\n"
"-C Don't convert password to uppercase\n"
"-P password Use this password\n"
"-n Do not use any password\n"
" If neither -P nor -n are given, you are\n"
" asked for a password.\n"
"-h print this help text\n"
"-C Don't convert password to uppercase\n"
"-P password Use this password\n"
"-n Do not use any password\n"
" If neither -P nor -n are given, you are\n"
" asked for a password.\n"
"-h print this help text\n"
"-v print ncpfs version number\n"
"\n");
"\n");
}

225
sutil/ncpumount.c
View File

@@ -16,7 +16,7 @@
#include <netdb.h>
#include <sys/stat.h>
#include <sys/types.h>
/* #include <sys/wait.h> */ /* generates a warning here */
/* #include <sys/wait.h> *//* generates a warning here */
extern pid_t waitpid(pid_t, int *, int);
#include <sys/errno.h>
#include <unistd.h>
@@ -38,36 +38,36 @@ static char *progname;
static void
usage(void)
{
printf("usage: %s mount-point\n", progname);
printf("usage: %s mount-point\n", progname);
}
static int
umount_ok(const char *mount_point)
{
int fid = open(mount_point, O_RDONLY, 0);
uid_t mount_uid;
int fid = open(mount_point, O_RDONLY, 0);
uid_t mount_uid;
if (fid == -1) {
fprintf(stderr, "Could not open %s: %s\n",
mount_point, strerror(errno));
return -1;
}
if (ioctl(fid, NCP_IOC_GETMOUNTUID, &mount_uid) != 0) {
fprintf(stderr, "%s probably not ncp-filesystem\n",
mount_point);
return -1;
}
if ( (getuid() != 0)
&& (mount_uid != getuid())) {
fprintf(stderr, "You are not allowed to umount %s\n",
mount_point);
return -1;
}
close(fid);
return 0;
if (fid == -1)
{
fprintf(stderr, "Could not open %s: %s\n",
mount_point, strerror(errno));
return -1;
}
if (ioctl(fid, NCP_IOC_GETMOUNTUID, &mount_uid) != 0)
{
fprintf(stderr, "%s probably not ncp-filesystem\n",
mount_point);
return -1;
}
if ((getuid() != 0)
&& (mount_uid != getuid()))
{
fprintf(stderr, "You are not allowed to umount %s\n",
mount_point);
return -1;
}
close(fid);
return 0;
}
/* Make a canonical pathname from PATH. Returns a freshly malloced string.
@@ -76,118 +76,117 @@ umount_ok(const char *mount_point)
is not a legal pathname for ``/dev/fd0.'' Anything we cannot parse
we return unmodified. */
char *
canonicalize (const char *path)
canonicalize(const char *path)
{
char *canonical = malloc (PATH_MAX + 1);
if (path == NULL)
return NULL;
if (realpath (path, canonical))
return canonical;
char *canonical = malloc(PATH_MAX + 1);
if (strlen(path) > PATH_MAX)
{
return NULL;
}
if (path == NULL)
return NULL;
strcpy (canonical, path);
return canonical;
if (realpath(path, canonical))
return canonical;
if (strlen(path) > PATH_MAX)
{
return NULL;
}
strcpy(canonical, path);
return canonical;
}
int
int
main(int argc, char *argv[])
{
int fd;
int fd;
char* mount_point;
char *mount_point;
struct mntent *mnt;
FILE* mtab;
FILE* new_mtab;
struct mntent *mnt;
FILE *mtab;
FILE *new_mtab;
progname = argv[0];
progname = argv[0];
if (geteuid() != 0) {
fprintf(stderr, "%s must be installed suid root\n", progname);
exit(1);
}
if (argc != 2) {
usage();
exit(1);
}
mount_point = canonicalize(argv[1]);
if (geteuid() != 0)
{
fprintf(stderr, "%s must be installed suid root\n", progname);
exit(1);
}
if (argc != 2)
{
usage();
exit(1);
}
mount_point = canonicalize(argv[1]);
if (mount_point == NULL)
{
fprintf(stderr, "Invalid mount point: %s\n", argv[1]);
exit(1);
}
if (umount_ok(mount_point) != 0) {
if (umount_ok(mount_point) != 0)
{
fprintf(stderr, "You are not allowed to umount %s\n",
mount_point);
exit(1);
}
if (umount(mount_point) != 0) {
fprintf(stderr, "Could not umount %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
if ((fd = open(MOUNTED"~", O_RDWR|O_CREAT|O_EXCL, 0600)) == -1)
{
fprintf(stderr, "Can't get "MOUNTED"~ lock file");
return 1;
}
close(fd);
if ((mtab = setmntent(MOUNTED, "r")) == NULL) {
fprintf(stderr, "Can't open " MOUNTED ": %s\n",
strerror(errno));
return 1;
}
exit(1);
}
if (umount(mount_point) != 0)
{
fprintf(stderr, "Could not umount %s: %s\n",
mount_point, strerror(errno));
exit(1);
}
if ((fd = open(MOUNTED "~", O_RDWR | O_CREAT | O_EXCL, 0600)) == -1)
{
fprintf(stderr, "Can't get " MOUNTED "~ lock file");
return 1;
}
close(fd);
if ((mtab = setmntent(MOUNTED, "r")) == NULL)
{
fprintf(stderr, "Can't open " MOUNTED ": %s\n",
strerror(errno));
return 1;
}
#define MOUNTED_TMP MOUNTED".tmp"
if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL) {
fprintf(stderr, "Can't open " MOUNTED_TMP ": %s\n",
strerror(errno));
endmntent(mtab);
return 1;
}
if ((new_mtab = setmntent(MOUNTED_TMP, "w")) == NULL)
{
fprintf(stderr, "Can't open " MOUNTED_TMP ": %s\n",
strerror(errno));
endmntent(mtab);
return 1;
}
while ((mnt = getmntent(mtab)) != NULL)
{
if (strcmp(mnt->mnt_dir, mount_point) != 0)
{
addmntent(new_mtab, mnt);
}
}
while ((mnt = getmntent(mtab)) != NULL) {
if (strcmp(mnt->mnt_dir, mount_point) != 0) {
addmntent(new_mtab, mnt);
}
}
endmntent(mtab);
endmntent(mtab);
if (fchmod (fileno (new_mtab), S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) < 0) {
fprintf(stderr, "Error changing mode of %s: %s\n",
MOUNTED_TMP, strerror(errno));
exit(1);
}
endmntent(new_mtab);
if (rename(MOUNTED_TMP, MOUNTED) < 0) {
fprintf(stderr, "Cannot rename %s to %s: %s\n",
MOUNTED, MOUNTED_TMP, strerror(errno));
exit(1);
}
if (unlink(MOUNTED"~") == -1)
{
fprintf(stderr, "Can't remove "MOUNTED"~");
return 1;
}
if (fchmod(fileno(new_mtab), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0)
{
fprintf(stderr, "Error changing mode of %s: %s\n",
MOUNTED_TMP, strerror(errno));
exit(1);
}
endmntent(new_mtab);
if (rename(MOUNTED_TMP, MOUNTED) < 0)
{
fprintf(stderr, "Cannot rename %s to %s: %s\n",
MOUNTED, MOUNTED_TMP, strerror(errno));
exit(1);
}
if (unlink(MOUNTED "~") == -1)
{
fprintf(stderr, "Can't remove " MOUNTED "~");
return 1;
}
return 0;
}
}

93
sutil/nwcrypt.c
View File

@@ -1,17 +1,17 @@
/*$*********************************************************
$*
$* This code has been taken from DDJ 11/93, from an
$* article by Pawel Szczerbina.
$*
$* Password encryption routines follow.
$* Converted to C from Barry Nance's Pascal
$* prog published in the March -93 issue of Byte.
$*
$* Adapted to be useable for ncpfs by
$* Volker Lendecke <lendecke@namu01.gwdg.de> in
$* October 1995.
$*
$**********************************************************/
$*
$* This code has been taken from DDJ 11/93, from an
$* article by Pawel Szczerbina.
$*
$* Password encryption routines follow.
$* Converted to C from Barry Nance's Pascal
$* prog published in the March -93 issue of Byte.
$*
$* Adapted to be useable for ncpfs by
$* Volker Lendecke <lendecke@namu01.gwdg.de> in
$* October 1995.
$*
$********************************************************* */
/****************************************************************************
@@ -91,28 +91,28 @@ typedef unsigned char buf8[8];
typedef unsigned char buf4[4];
static unsigned char encrypttable[256] =
{0x7,0x8,0x0,0x8,0x6,0x4,0xE,0x4,0x5,0xC,0x1,0x7,0xB,0xF,0xA,0x8,
0xF,0x8,0xC,0xC,0x9,0x4,0x1,0xE,0x4,0x6,0x2,0x4,0x0,0xA,0xB,0x9,
0x2,0xF,0xB,0x1,0xD,0x2,0x1,0x9,0x5,0xE,0x7,0x0,0x0,0x2,0x6,0x6,
0x0,0x7,0x3,0x8,0x2,0x9,0x3,0xF,0x7,0xF,0xC,0xF,0x6,0x4,0xA,0x0,
0x2,0x3,0xA,0xB,0xD,0x8,0x3,0xA,0x1,0x7,0xC,0xF,0x1,0x8,0x9,0xD,
0x9,0x1,0x9,0x4,0xE,0x4,0xC,0x5,0x5,0xC,0x8,0xB,0x2,0x3,0x9,0xE,
0x7,0x7,0x6,0x9,0xE,0xF,0xC,0x8,0xD,0x1,0xA,0x6,0xE,0xD,0x0,0x7,
0x7,0xA,0x0,0x1,0xF,0x5,0x4,0xB,0x7,0xB,0xE,0xC,0x9,0x5,0xD,0x1,
0xB,0xD,0x1,0x3,0x5,0xD,0xE,0x6,0x3,0x0,0xB,0xB,0xF,0x3,0x6,0x4,
0x9,0xD,0xA,0x3,0x1,0x4,0x9,0x4,0x8,0x3,0xB,0xE,0x5,0x0,0x5,0x2,
0xC,0xB,0xD,0x5,0xD,0x5,0xD,0x2,0xD,0x9,0xA,0xC,0xA,0x0,0xB,0x3,
0x5,0x3,0x6,0x9,0x5,0x1,0xE,0xE,0x0,0xE,0x8,0x2,0xD,0x2,0x2,0x0,
0x4,0xF,0x8,0x5,0x9,0x6,0x8,0x6,0xB,0xA,0xB,0xF,0x0,0x7,0x2,0x8,
0xC,0x7,0x3,0xA,0x1,0x4,0x2,0x5,0xF,0x7,0xA,0xC,0xE,0x5,0x9,0x3,
0xE,0x7,0x1,0x2,0xE,0x1,0xF,0x4,0xA,0x6,0xC,0x6,0xF,0x4,0x3,0x0,
0xC,0x0,0x3,0x6,0xF,0x8,0x7,0xB,0x2,0xD,0xC,0x6,0xA,0xA,0x8,0xD};
{0x7, 0x8, 0x0, 0x8, 0x6, 0x4, 0xE, 0x4, 0x5, 0xC, 0x1, 0x7, 0xB, 0xF, 0xA, 0x8,
0xF, 0x8, 0xC, 0xC, 0x9, 0x4, 0x1, 0xE, 0x4, 0x6, 0x2, 0x4, 0x0, 0xA, 0xB, 0x9,
0x2, 0xF, 0xB, 0x1, 0xD, 0x2, 0x1, 0x9, 0x5, 0xE, 0x7, 0x0, 0x0, 0x2, 0x6, 0x6,
0x0, 0x7, 0x3, 0x8, 0x2, 0x9, 0x3, 0xF, 0x7, 0xF, 0xC, 0xF, 0x6, 0x4, 0xA, 0x0,
0x2, 0x3, 0xA, 0xB, 0xD, 0x8, 0x3, 0xA, 0x1, 0x7, 0xC, 0xF, 0x1, 0x8, 0x9, 0xD,
0x9, 0x1, 0x9, 0x4, 0xE, 0x4, 0xC, 0x5, 0x5, 0xC, 0x8, 0xB, 0x2, 0x3, 0x9, 0xE,
0x7, 0x7, 0x6, 0x9, 0xE, 0xF, 0xC, 0x8, 0xD, 0x1, 0xA, 0x6, 0xE, 0xD, 0x0, 0x7,
0x7, 0xA, 0x0, 0x1, 0xF, 0x5, 0x4, 0xB, 0x7, 0xB, 0xE, 0xC, 0x9, 0x5, 0xD, 0x1,
0xB, 0xD, 0x1, 0x3, 0x5, 0xD, 0xE, 0x6, 0x3, 0x0, 0xB, 0xB, 0xF, 0x3, 0x6, 0x4,
0x9, 0xD, 0xA, 0x3, 0x1, 0x4, 0x9, 0x4, 0x8, 0x3, 0xB, 0xE, 0x5, 0x0, 0x5, 0x2,
0xC, 0xB, 0xD, 0x5, 0xD, 0x5, 0xD, 0x2, 0xD, 0x9, 0xA, 0xC, 0xA, 0x0, 0xB, 0x3,
0x5, 0x3, 0x6, 0x9, 0x5, 0x1, 0xE, 0xE, 0x0, 0xE, 0x8, 0x2, 0xD, 0x2, 0x2, 0x0,
0x4, 0xF, 0x8, 0x5, 0x9, 0x6, 0x8, 0x6, 0xB, 0xA, 0xB, 0xF, 0x0, 0x7, 0x2, 0x8,
0xC, 0x7, 0x3, 0xA, 0x1, 0x4, 0x2, 0x5, 0xF, 0x7, 0xA, 0xC, 0xE, 0x5, 0x9, 0x3,
0xE, 0x7, 0x1, 0x2, 0xE, 0x1, 0xF, 0x4, 0xA, 0x6, 0xC, 0x6, 0xF, 0x4, 0x3, 0x0,
0xC, 0x0, 0x3, 0x6, 0xF, 0x8, 0x7, 0xB, 0x2, 0xD, 0xC, 0x6, 0xA, 0xA, 0x8, 0xD};
static buf32 encryptkeys =
{0x48,0x93,0x46,0x67,0x98,0x3D,0xE6,0x8D,
0xB7,0x10,0x7A,0x26,0x5A,0xB9,0xB1,0x35,
0x6B,0x0F,0xD5,0x70,0xAE,0xFB,0xAD,0x11,
0xF4,0x47,0xDC,0xA7,0xEC,0xCF,0x50,0xC0};
static buf32 encryptkeys =
{0x48, 0x93, 0x46, 0x67, 0x98, 0x3D, 0xE6, 0x8D,
0xB7, 0x10, 0x7A, 0x26, 0x5A, 0xB9, 0xB1, 0x35,
0x6B, 0x0F, 0xD5, 0x70, 0xAE, 0xFB, 0xAD, 0x11,
0xF4, 0x47, 0xDC, 0xA7, 0xEC, 0xCF, 0x50, 0xC0};
static void
@@ -128,15 +128,16 @@ shuffle1(buf32 temp, unsigned char *target)
{
for (s = 0; s <= 31; ++s)
{
b3 = (temp[s]+b4) ^ (temp[(s+b4)&31] - encryptkeys[s]);
b3 = (temp[s] + b4) ^ (temp[(s + b4) & 31] - encryptkeys[s]);
b4 = b4 + b3;
temp[s] = b3;
}
}
for (i = 0; i <= 15; ++i) {
target[i] = encrypttable[temp[ 2*i ]]
| (encrypttable[temp[ 2*i + 1]] << 4);
for (i = 0; i <= 15; ++i)
{
target[i] = encrypttable[temp[2 * i]]
| (encrypttable[temp[2 * i + 1]] << 4);
}
}
@@ -148,12 +149,14 @@ shuffle(const unsigned char *lon, const unsigned char *buf, int buflen,
int b2, d, s;
buf32 temp;
while ( (buflen > 0)
&& (buf[buflen - 1] == 0)) {
while ((buflen > 0)
&& (buf[buflen - 1] == 0))
{
buflen = buflen - 1;
}
for (s = 0; s < 32; s++) {
for (s = 0; s < 32; s++)
{
temp[s] = 0;
}
@@ -176,17 +179,17 @@ shuffle(const unsigned char *lon, const unsigned char *buf, int buflen,
{
b2 = d;
temp[s] = temp[s] ^ encryptkeys[s];
} else {
} else
{
temp[s] = temp[s] ^ buf[b2];
b2 = b2 + 1;
}
}
}
for (s = 0; s <= 31; ++s)
temp[s] = temp[s] ^ lon[s & 3];
shuffle1(temp,target);
shuffle1(temp, target);
}
@@ -198,7 +201,7 @@ nw_encrypt(const unsigned char *fra,
buf32 k;
int s;
shuffle(&(fra[0]), buf, 16, &(k[ 0]));
shuffle(&(fra[0]), buf, 16, &(k[0]));
shuffle(&(fra[4]), buf, 16, &(k[16]));
for (s = 0; s <= 15; ++s)

20
sutil/nwsfind.c
View File

@@ -25,16 +25,16 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [server]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [server]\n", progname);
printf("\n"
"-t Server type, default: File server\n"
"-h Print this help text\n"
"\n");
}
static void
swallow_error(const char * name, long code, const char *format, va_list arg)
swallow_error(const char *name, long code, const char *format, va_list arg)
{
printf("%s ", error_message(code));
vfprintf(stdout, format, arg);
@@ -58,7 +58,8 @@ main(int argc, char *argv[])
while ((opt = getopt(argc, argv, "t:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 't':
object_type = atoi(optarg);
break;
@@ -72,13 +73,12 @@ main(int argc, char *argv[])
}
}
if (optind < argc-1)
if (optind < argc - 1)
{
usage();
exit(1);
}
if (optind == argc-1)
if (optind == argc - 1)
{
server = argv[optind];
if (strlen(server) >= NCP_BINDERY_NAME_LEN)
@@ -86,8 +86,7 @@ main(int argc, char *argv[])
com_err(argv[0], ENAMETOOLONG, "server name too long");
exit(1);
}
}
}
result = ncp_find_server(&server, object_type, &err);
if (result == NULL)
@@ -95,7 +94,6 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when trying to find server");
exit(1);
}
ipx_print_saddr(result);
printf(" %s\n", server);
return 0;

2
util/Makefile
View File

@@ -6,7 +6,7 @@ USERUTILS = slist pqlist nwfsinfo pserver nprint nsend ncopy nwpasswd
USERUTILS += nwbols nwbocreate nwborm nwboprops
USERUTILS += nwbpcreate nwbprm nwbpvalues nwbpadd nwbpset
USERUTILS += nwgrant nwrevoke nwuserlist nwrights nwauth
USERUTILS += nwfstime
USERUTILS += nwfstime nwvolinfo
SBINUTILS = nwmsg
UTILS = $(USERUTILS) $(SBINUTILS) ncptest

1337
util/ncopy.c
View File

File diff suppressed because it is too large Load Diff

30
util/ncptest.c
View File

@@ -19,7 +19,7 @@
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
/* #include <sys/wait.h> */ /* generates a warning here */
/* #include <sys/wait.h> *//* generates a warning here */
extern pid_t waitpid(pid_t, int *, int);
#include <sys/errno.h>
#include <unistd.h>
@@ -41,7 +41,8 @@ extern pid_t waitpid(pid_t, int *, int);
void
test_connlist(struct ncp_conn *conn)
{
__u8 conn_list[256] = {0,};
__u8 conn_list[256] =
{0,};
int no;
ncp_get_connlist(conn, NCP_BINDERY_USER, "SUPERVISOR", &no,
@@ -52,7 +53,8 @@ test_connlist(struct ncp_conn *conn)
void
test_send(struct ncp_conn *conn)
{
__u8 conn_list[256] = {0,};
__u8 conn_list[256] =
{0,};
int no;
if (ncp_get_connlist(conn, NCP_BINDERY_USER, "ME", &no,
@@ -60,7 +62,6 @@ test_send(struct ncp_conn *conn)
{
no = 0;
}
if (no > 0)
{
ncp_send_broadcast(conn, no, conn_list, "Hallo");
@@ -85,21 +86,18 @@ test_create(struct ncp_conn *conn)
printf("lookup public error\n");
return;
}
if (ncp_alloc_short_dir_handle(conn, &me, NCP_ALLOC_TEMPORARY,
&dir_handle) != 0)
{
printf("alloc_dir_handle error\n");
return;
}
if (ncp_create_file(conn, dir_handle, "BLUB.TXT", 0,
&new_file) != 0)
{
printf("create error\n");
return;
}
if (ncp_dealloc_dir_handle(conn, dir_handle) != 0)
{
printf("dealloc error\n");
@@ -114,15 +112,15 @@ test_change(struct ncp_conn *conn)
unsigned char ncp_key[8];
struct ncp_bindery_object user;
if ((result = ncp_get_encryption_key(conn, ncp_key)) != 0) {
if ((result = ncp_get_encryption_key(conn, ncp_key)) != 0)
{
return result;
}
if ((result = ncp_get_bindery_object_id(conn, 1,
"ME", &user)) != 0) {
"ME", &user)) != 0)
{
return result;
}
if ((result = ncp_change_login_passwd(conn, &user, ncp_key,
"MEE", "ME")) != 0)
{
@@ -149,16 +147,14 @@ test_readdir(struct ncp_conn *conn)
printf("lookup blub error\n");
return;
}
if (ncp_initialize_search(conn, &sys, 0, &seq) != 0)
{
printf("init error\n");
return;
}
while (ncp_search_for_file_or_subdir(conn, &seq, &entry) == 0)
{
struct nw_info_struct nfs;
struct nw_info_struct nfs;
printf("found: %s\n", entry.entryName);
if (ncp_obtain_file_or_subdir_info(conn, NW_NS_DOS, NW_NS_NFS,
0x8006, RIM_ALL,
@@ -168,7 +164,7 @@ test_readdir(struct ncp_conn *conn)
&nfs) == 0)
{
printf("nfs name: %s\n", nfs.entryName);
}
}
if (ncp_obtain_file_or_subdir_info(conn, NW_NS_DOS, NW_NS_OS2,
0x8006, RIM_ALL,
entry.volNumber,
@@ -177,7 +173,7 @@ test_readdir(struct ncp_conn *conn)
&nfs) == 0)
{
printf("os2 name: %s\n", nfs.entryName);
}
}
}
}
@@ -199,7 +195,6 @@ test_rights(struct ncp_conn *conn)
printf("lookup me error\n");
return;
}
if (ncp_get_eff_directory_rights(conn, 0, 0, 0x8006,
sys.volNumber, sys.DosDirNum, NULL,
&rights) != 0)
@@ -231,7 +226,6 @@ main(int argc, char *argv[])
com_err(argv[0], err, "in ncp_initialize");
return 1;
}
test_rights(conn);
ncp_close(conn);
return 0;

97
util/nprint.c
View File

@@ -19,7 +19,7 @@
static char *progname;
static void
usage(void);
usage(void);
static void help(void);
void
@@ -46,25 +46,25 @@ main(int argc, char *argv[])
progname = argv[0];
memzero(j); memzero(pj); memzero(q);
memzero(j);
memzero(pj);
memzero(q);
if ( (argc == 2)
if ((argc == 2)
&& (strcmp(argv[1], "-h") == 0))
{
help();
exit(0);
}
if ((conn = ncp_initialize(&argc, argv, 1, &err)) == NULL)
{
com_err(argv[0], err, "when initializing connection");
exit(1);
}
/*
* Fill in default values for print job
*/
j.j.TargetServerID = 0xffffffff; /* any server */
j.j.TargetServerID = 0xffffffff; /* any server */
/* at once */
memset(&(j.j.TargetExecTime), 0xff, sizeof(j.j.TargetExecTime));
j.j.JobType = htons(0);
@@ -78,9 +78,10 @@ main(int argc, char *argv[])
pj.Rows = htons(80);
strcpy(pj.FnameHeader, "stdin");
while ((opt = getopt(argc, argv, "h?q:d:p:b:f:l:r:c:t:F:TN"))!=EOF)
while ((opt = getopt(argc, argv, "h?q:d:p:b:f:l:r:c:t:F:TN")) != EOF)
{
switch (opt) {
switch (opt)
{
case 'h':
case '?':
help();
@@ -93,8 +94,7 @@ main(int argc, char *argv[])
{
strncpy(pj.Path, optarg,
sizeof(pj.Path));
}
else
} else
{
strcpy(pj.Path, optarg);
}
@@ -106,8 +106,7 @@ main(int argc, char *argv[])
{
strncpy(pj.BannerName, optarg,
sizeof(pj.BannerName));
}
else
} else
{
strcpy(pj.BannerName, optarg);
}
@@ -119,8 +118,7 @@ main(int argc, char *argv[])
{
strncpy(pj.FnameBanner, optarg,
sizeof(pj.FnameBanner));
}
else
} else
{
strcpy(pj.FnameBanner, optarg);
}
@@ -205,13 +203,12 @@ main(int argc, char *argv[])
{
strncpy(j.j.JobTextDescription, optarg,
sizeof(j.j.JobTextDescription));
}
else
} else
{
strcpy(j.j.JobTextDescription, optarg);
}
break;
default:
usage();
ncp_close(conn);
@@ -219,20 +216,18 @@ main(int argc, char *argv[])
}
}
if (optind != argc-1)
if (optind != argc - 1)
{
usage();
ncp_close(conn);
exit(1);
}
file_name = argv[optind];
if (strcmp(file_name, "-") == 0)
{
file = 0; /* stdin */
}
else
} else
{
file = open(file_name, O_RDONLY, 0);
if (file < 0)
@@ -241,13 +236,11 @@ main(int argc, char *argv[])
ncp_close(conn);
exit(1);
}
if (strlen(file_name) >= sizeof(pj.FnameHeader))
{
strncpy(pj.FnameHeader, file_name,
sizeof(pj.FnameHeader));
}
else
} else
{
strcpy(pj.FnameHeader, file_name);
}
@@ -258,8 +251,7 @@ main(int argc, char *argv[])
{
strncpy(pj.FnameBanner, file_name,
sizeof(pj.FnameBanner));
}
else
} else
{
strcpy(pj.FnameBanner, file_name);
}
@@ -277,38 +269,35 @@ main(int argc, char *argv[])
ncp_close(conn);
exit(1);
}
if (ncp_create_queue_job_and_file(conn, q.object_id, &j) != 0)
{
printf("create error\n");
ncp_close(conn);
exit(1);
}
written = 0;
do
{
read_this_time = read(file, buf, sizeof(buf));
read_this_time = read(file, buf, sizeof(buf));
if (read_this_time < 0)
{
break;
}
if (ncp_write(conn, j.file_handle,
written, read_this_time, buf) < read_this_time)
{
break;
}
written += read_this_time;
} while (read_this_time > 0);
}
while (read_this_time > 0);
close(file);
if (ncp_close_file_and_start_job(conn, q.object_id, &j) != 0) {
if (ncp_close_file_and_start_job(conn, q.object_id, &j) != 0)
{
printf("close error\n");
}
ncp_close(conn);
return;
}
@@ -322,25 +311,25 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] file\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] file\n", progname);
printf("\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-q queue name Name of the printing queue to use\n"
"-d job desc Job description\n"
"-p path name Path name to appear on banner\n"
"-b bannername Banner name (up to 12 chars)\n"
"-f filename Filename to appear on banner\n"
"-l lines Number of lines per page\n"
"-r rows Number of rows per page\n"
"-t tab Number of spaces per tab\n"
"-T Print server tab expantion\n"
"-N Surpress print server form feeds\n"
"-F form # Form number to print on\n"
"-h print this help text\n"
"\n");
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-q queue name Name of the printing queue to use\n"
"-d job desc Job description\n"
"-p path name Path name to appear on banner\n"
"-b bannername Banner name (up to 12 chars)\n"
"-f filename Filename to appear on banner\n"
"-l lines Number of lines per page\n"
"-r rows Number of rows per page\n"
"-t tab Number of spaces per tab\n"
"-T Print server tab expantion\n"
"-N Surpress print server form feeds\n"
"-F form # Form number to print on\n"
"-h print this help text\n"
"\n");
}

7
util/nsend.c
View File

@@ -16,7 +16,8 @@ int
main(int argc, char **argv)
{
struct ncp_conn *conn;
__u8 conn_list[256] = {0,};
__u8 conn_list[256] =
{0,};
int no_conn;
char *message = NULL;
@@ -28,14 +29,12 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
exit(1);
}
if (argc != 3)
{
fprintf(stderr, "usage: %s [options] user message\n", argv[0]);
ncp_close(conn);
exit(1);
}
user = argv[1];
message = argv[2];
@@ -46,14 +45,12 @@ main(int argc, char **argv)
ncp_close(conn);
exit(1);
}
if (no_conn == 0)
{
fprintf(stderr, "No connection found for %s\n", user);
ncp_close(conn);
exit(1);
}
if ((err = ncp_send_broadcast(conn, no_conn, conn_list, message)) != 0)
{
com_err(argv[0], err, "in send_broadcast");

19
util/nwauth.c
View File

@@ -23,18 +23,18 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-U username Username sent to server\n"
"-t type Object type (decimal value)\n"
"\n");
}
static void
swallow_error(const char * s, long x, const char *t, va_list arg)
swallow_error(const char *s, long x, const char *t, va_list arg)
{
return;
}
@@ -59,10 +59,10 @@ main(int argc, char *argv[])
{
set_com_err_hook(swallow_error);
}
while ((opt = getopt(argc, argv, "h?S:U:t:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'S':
server = optarg;
break;
@@ -90,13 +90,11 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when trying to find server");
exit(1);
}
if (ncp_find_fileserver(spec->server, &err) == NULL)
{
com_err(argv[0], err, "when trying to find server");
exit(1);
}
spec->login_type = object_type;
memset(spec->password, 0, sizeof(spec->password));
@@ -109,8 +107,7 @@ main(int argc, char *argv[])
exit(1);
}
strcpy(spec->password, str);
}
else
} else
{
fgets(spec->password, sizeof(spec->password), stdin);
}

31
util/nwbocreate.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of created object\n"
"-t type Object type (decimal value)\n"
@@ -63,8 +63,8 @@ parse_security(const char *security)
return 4;
}
return -1;
}
}
int
main(int argc, char *argv[])
{
@@ -76,7 +76,7 @@ main(int argc, char *argv[])
int read_sec = 1; /* logged read */
int write_sec = 3; /* supervisor write */
int result = 1;
int opt;
progname = argv[0];
@@ -86,10 +86,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:r:w:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -137,25 +137,22 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (ncp_create_bindery_object(conn, object_type, object_name,
(write_sec << 4) + read_sec, 0) != 0)
{
fprintf(stderr, "%s: Could not create the object\n", argv[0]);
}
else
} else
{
result = 0;
}
finished:
finished:
ncp_close(conn);
return result;
}

32
util/nwbols.c
View File

@@ -25,15 +25,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-t type Object type to be listed (decimal)\n"
"-o object Object pattern\n"
@@ -63,10 +63,10 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "h?vt:o:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'h':
case '?':
help();
@@ -91,7 +91,6 @@ main(int argc, char **argv)
usage();
exit(1);
}
for (p = pattern; *p != '\0'; p++)
{
*p = toupper(*p);
@@ -106,17 +105,16 @@ main(int argc, char **argv)
if (verbose != 0)
{
printf("%s %08X %04X %d %02X %d\n",
o.object_name, (unsigned int)o.object_id,
(unsigned int)o.object_type,
o.object_name, (unsigned int) o.object_id,
(unsigned int) o.object_type,
o.object_flags, o.object_security,
o.object_has_prop);
}
else
} else
{
printf("%s %08X %04X\n",
o.object_name, (unsigned int)o.object_id,
(unsigned int)o.object_type);
}
o.object_name, (unsigned int) o.object_id,
(unsigned int) o.object_type);
}
}
ncp_close(conn);

27
util/nwboprops.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object inspected\n"
"-t type Object type (decimal value)\n"
@@ -47,7 +47,7 @@ main(int argc, char *argv[])
long err;
struct ncp_property_info info;
int result = 1;
int verbose = 0;
int opt;
@@ -59,10 +59,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:v")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -89,14 +89,12 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
info.search_instance = 0xffffffff;
while (ncp_scan_property(conn, object_type, object_name,
@@ -108,14 +106,13 @@ main(int argc, char *argv[])
info.property_name, info.property_flags,
info.property_security,
info.value_available_flag);
}
else
} else
{
printf("%s\n", info.property_name);
}
}
finished:
finished:
ncp_close(conn);
return result;
}

27
util/nwborm.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object to be removed\n"
"-t type Object type (decimal value)\n"
@@ -46,7 +46,7 @@ main(int argc, char *argv[])
long err;
int result = 1;
int opt;
progname = argv[0];
@@ -56,10 +56,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -83,24 +83,21 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (ncp_delete_bindery_object(conn, object_type, object_name) != 0)
{
fprintf(stderr, "%s: Could not delete the object\n", argv[0]);
}
else
} else
{
result = 0;
}
finished:
finished:
ncp_close(conn);
return result;
}

45
util/nwbpadd.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] [values]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] [values]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of accessed object\n"
"-t type Object type (decimal value)\n"
@@ -66,10 +66,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:p:v:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -106,28 +106,24 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (property_name == NULL)
{
fprintf(stderr, "%s: You must specify a property name\n",
argv[0]);
goto finished;
}
if (optind > argc-1)
if (optind > argc - 1)
{
fprintf(stderr, "%s: You must specify a property value\n",
argv[0]);
goto finished;
}
value = argv[optind];
optind += 1;
@@ -137,7 +133,6 @@ main(int argc, char *argv[])
fprintf(stderr, "%s: Could not find property\n", argv[0]);
goto finished;
}
if ((info.property_flags & 2) != 0)
{
/* Property is of type SET */
@@ -150,7 +145,6 @@ main(int argc, char *argv[])
progname, property_name);
goto finished;
}
if (ncp_get_bindery_object_name(conn,
ntohl(strtol(value, NULL, 16)),
&o) != 0)
@@ -159,7 +153,6 @@ main(int argc, char *argv[])
progname, value);
goto finished;
}
if (ncp_add_object_to_set(conn, object_type, object_name,
property_name,
o.object_type, o.object_name) != 0)
@@ -167,12 +160,11 @@ main(int argc, char *argv[])
fprintf(stderr, "%s: could not add object %s\n",
progname, o.object_name);
goto finished;
}
}
else
}
} else
{
/* Property is of type ITEM */
char contents[255*128];
char contents[255 * 128];
int segno = 1;
int length;
@@ -189,8 +181,7 @@ main(int argc, char *argv[])
goto finished;
}
strcpy(contents, value);
}
else
} else
{
/* value is the byte count */
int i;
@@ -219,15 +210,15 @@ main(int argc, char *argv[])
for (segno = 1; segno <= 255; segno++)
{
struct nw_property segment;
int offset = (segno-1)*128;
int offset = (segno - 1) * 128;
if ( offset > length )
if (offset > length)
{
/* everything written */
break;
}
memcpy(segment.value, &(contents[offset]), 128);
segment.more_flag = segno*128 < length;
segment.more_flag = segno * 128 < length;
if (ncp_write_property_value(conn, object_type,
object_name,
property_name,
@@ -241,7 +232,7 @@ main(int argc, char *argv[])
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}

34
util/nwbpcreate.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object\n"
"-t type Object type (decimal value)\n"
@@ -65,8 +65,8 @@ parse_security(const char *security)
return 4;
}
return -1;
}
}
int
main(int argc, char *argv[])
{
@@ -80,7 +80,7 @@ main(int argc, char *argv[])
int read_sec = 1; /* logged read */
int write_sec = 3; /* supervisor write */
int result = 1;
int opt;
progname = argv[0];
@@ -90,10 +90,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:p:sr:w:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -154,34 +154,30 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (property_name == NULL)
{
fprintf(stderr, "%s: You must specify a property name\n",
argv[0]);
goto finished;
}
if (ncp_create_property(conn, object_type, object_name,
property_name,
property_is_set ? 2 : 0,
(write_sec << 4) + read_sec) != 0)
{
fprintf(stderr, "%s: Could not create the property\n",argv[0]);
}
else
fprintf(stderr, "%s: Could not create the property\n", argv[0]);
} else
{
result = 0;
}
finished:
finished:
ncp_close(conn);
return result;
}

30
util/nwbprm.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object\n"
"-t type Object type (decimal value)\n"
@@ -48,7 +48,7 @@ main(int argc, char *argv[])
long err;
int result = 1;
int opt;
progname = argv[0];
@@ -58,10 +58,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:p:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -95,32 +95,28 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (property_name == NULL)
{
fprintf(stderr, "%s: You must specify a property name\n",
argv[0]);
goto finished;
}
if (ncp_delete_property(conn, object_type, object_name,
property_name) != 0)
{
fprintf(stderr, "%s: Could not delete the property\n",argv[0]);
}
else
fprintf(stderr, "%s: Could not delete the property\n", argv[0]);
} else
{
result = 0;
}
finished:
finished:
ncp_close(conn);
return result;
}

51
util/nwbpset.c
View File

@@ -22,25 +22,25 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] [values]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] [values]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n");
}
static char *
get_line(char *buf, int len, FILE *stream)
get_line(char *buf, int len, FILE * stream)
{
char *result = fgets(buf, len, stream);
if (result != NULL)
{
buf[strlen(buf)-1] = '\0'; /* remove newline */
buf[strlen(buf) - 1] = '\0'; /* remove newline */
}
return result;
}
@@ -66,10 +66,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'h':
case '?':
help();
@@ -100,7 +100,6 @@ main(int argc, char *argv[])
fprintf(stderr, "Illegal format on stdin\n");
goto finished;
}
memset(buf, 0, sizeof(buf));
if (get_line(buf, sizeof(buf), stdin) == NULL)
{
@@ -130,21 +129,19 @@ main(int argc, char *argv[])
"ITEM over existing SET");
goto finished;
}
if (info.property_security != property_security)
{
if (ncp_change_property_security(conn, object_type,
object_name,
property_name,
property_security)!=0)
property_security) != 0)
{
fprintf(stderr, "Could not change "
"property security\n");
goto finished;
}
}
}
else
} else
{
if (ncp_create_property(conn, object_type, object_name,
property_name, property_flag,
@@ -161,7 +158,7 @@ main(int argc, char *argv[])
int i;
int length;
int segno;
char property_value[255*128];
char property_value[255 * 128];
memset(property_value, 0, sizeof(property_value));
@@ -173,20 +170,20 @@ main(int argc, char *argv[])
}
property_value[i] = strtoul(buf, NULL, 16);
}
length = i-1;
length = i - 1;
for (segno = 1; segno <= 255; segno++)
{
struct nw_property segment;
int offset = (segno-1)*128;
int offset = (segno - 1) * 128;
if ( offset > length )
if (offset > length)
{
/* everything written */
break;
}
memcpy(segment.value, &(property_value[offset]), 128);
segment.more_flag = segno*128 < length;
segment.more_flag = segno * 128 < length;
if (ncp_write_property_value(conn, object_type,
object_name,
property_name,
@@ -196,8 +193,7 @@ main(int argc, char *argv[])
goto finished;
}
}
}
else
} else
{
/* SET property */
@@ -213,14 +209,13 @@ main(int argc, char *argv[])
fprintf(stderr, "Illegal format on stdin\n");
goto finished;
}
if (ncp_add_object_to_set(conn, object_type,
object_name, property_name,
element_type,
element_name) != 0)
{
if (conn->completion != 0xE9) /* object already
in set */
if (conn->completion != 0xE9) /* object already
in set */
{
fprintf(stderr, "Could not add object "
"to set\n");
@@ -228,11 +223,11 @@ main(int argc, char *argv[])
}
}
}
}
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}

238
util/nwbpvalues.c
View File

@@ -15,7 +15,7 @@
static char *progname;
static void
print_property(char *prop_name, __u8 *val, int segments);
print_property(char *prop_name, __u8 * val, int segments);
static void
usage(void)
@@ -26,15 +26,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object\n"
"-t type Object type (decimal value)\n"
@@ -51,7 +51,7 @@ main(int argc, char *argv[])
char *object_name = NULL;
int object_type = -1;
char *property_name = NULL;
__u8 property_value[255*128];
__u8 property_value[255 * 128];
int segno;
int verbose = 0;
int canonical = 0;
@@ -60,7 +60,7 @@ main(int argc, char *argv[])
long err;
int result = 1;
int opt;
progname = argv[0];
@@ -70,10 +70,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:p:vc")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -113,33 +113,29 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (property_name == NULL)
{
fprintf(stderr, "%s: You must specify a property name\n",
argv[0]);
goto finished;
}
if (ncp_scan_property(conn, object_type, object_name,
0xffffffff, property_name, &info) != 0)
{
fprintf(stderr, "%s: Could not find property\n", argv[0]);
goto finished;
}
segno = 1;
while (ncp_read_property_value(conn, object_type, object_name,
segno, property_name, &segment) == 0)
{
memcpy(&(property_value[(segno-1)*128]), segment.value, 128);
memcpy(&(property_value[(segno - 1) * 128]), segment.value, 128);
if ((segment.more_flag == 0) || (segno == 255))
{
break;
@@ -154,27 +150,24 @@ main(int argc, char *argv[])
info.property_name, info.property_flags, info.property_security);
}
if ((info.property_flags & 2) == 0)
{
/* ITEM property */
if (canonical != 0)
{
int i;
for (i = 0; i < segno*128; i++)
for (i = 0; i < segno * 128; i++)
{
printf("%-2.2x\n", property_value[i]);
}
}
else
} else
{
print_property(property_name, property_value, segno);
}
}
else
} else
{
int objects = 32 * segno;
__u32 *value = (__u32 *)property_value;
__u32 *value = (__u32 *) property_value;
int i = 0;
while (i < objects)
@@ -184,7 +177,7 @@ main(int argc, char *argv[])
if ((value[i] == 0) || (value[i] == 0xffffffff))
{
/* Continue with next segment */
i = ((i/32) + 1) * 32;
i = ((i / 32) + 1) * 32;
continue;
}
if (ncp_get_bindery_object_name(conn, ntohl(value[i]),
@@ -195,15 +188,13 @@ main(int argc, char *argv[])
printf("%-4.4x\n%s\n",
(unsigned int) o.object_type,
o.object_name);
}
else if (verbose != 0)
} else if (verbose != 0)
{
printf("%s %08X %04X\n",
o.object_name,
(unsigned int) o.object_id,
(unsigned int) o.object_type);
}
else
} else
{
printf("%s\n", o.object_name);
}
@@ -212,41 +203,41 @@ main(int argc, char *argv[])
}
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}
static void
print_unknown(__u8 *val)
print_unknown(__u8 * val)
{
int j = (128/16);
int j = (128 / 16);
while (1)
{
int i;
for ( i = 0 ; i < 16 ; i++ )
for (i = 0; i < 16; i++)
{
printf ( "%02X " , val[i] );
printf("%02X ", val[i]);
}
printf ( " [" );
for ( i = 0 ; i < 16 ; i++ )
printf(" [");
for (i = 0; i < 16; i++)
{
printf ( "%c" , isprint(val[i]) ? val[i] : '.');
printf("%c", isprint(val[i]) ? val[i] : '.');
}
j -= 1;
if ( j == 0 )
if (j == 0)
{
printf ( "]\n" );
printf("]\n");
return;
}
printf ( "]+\n" ) ;
printf("]+\n");
val += 16;
}
}
static void
print_string(__u8 *val)
print_string(__u8 * val)
{
puts(val);
}
@@ -256,65 +247,65 @@ print_station_addr(char *fmt, struct ncp_station_addr *addr, char *buff)
{
char *ret = buff;
while ( *fmt != 0 )
while (*fmt != 0)
{
switch ( *fmt )
switch (*fmt)
{
case '%':
switch ( *(++fmt) )
switch (*(++fmt))
{
case 'N': /* node */
{
int i ;
for ( i = 0 ; i < 6 ; buff += 2 , i++ )
case 'N': /* node */
{
sprintf(buff, "%02X",addr->Node[i]);
int i;
for (i = 0; i < 6; buff += 2, i++)
{
sprintf(buff, "%02X", addr->Node[i]);
}
}
}
break;
case 'S': /* Socket */
case 'S': /* Socket */
sprintf(buff, "%04X", htons(addr->Socket));
buff += 4 ;
break ;
case 'L': /* Lan */
buff += 4;
break;
case 'L': /* Lan */
sprintf(buff, "%08lX", htonl(addr->NetWork));
buff += 8 ;
break ;
buff += 8;
break;
case '%':
*buff++ = '%';
default:
break ;
break;
}
if (*fmt)
{
fmt++ ;
fmt++;
}
break ;
break;
default:
*buff++ = *fmt++ ;
*buff++ = *fmt++;
}
}
*buff = 0 ;
return ret ;
*buff = 0;
return ret;
}
void
print_login_control ( __u8 *val )
print_login_control(__u8 * val)
{
int i , j , mask;
char buff[32];
struct ncp_prop_login_control *a =(struct ncp_prop_login_control *)val;
int i, j, mask;
char buff[32];
struct ncp_prop_login_control *a = (struct ncp_prop_login_control *) val;
static char *days[]
= { "Sun" , "Mon" , "Tue" , "Wen" , "Thu" , "Fri" , "Sat" } ;
=
{"Sun", "Mon", "Tue", "Wen", "Thu", "Fri", "Sat"};
if (a->LastLogin[2] || a->LastLogin[1] || a->LastLogin[0] ||
a->LastLogin[3] || a->LastLogin[4] || a->LastLogin[5])
{
printf("Last Login: %d.%d.%02d at %2d:%02d:%02d\n",
a->LastLogin[2] , a->LastLogin[1] , a->LastLogin[0] ,
a->LastLogin[3] , a->LastLogin[4] , a->LastLogin[5]);
}
else
a->LastLogin[2], a->LastLogin[1], a->LastLogin[0],
a->LastLogin[3], a->LastLogin[4], a->LastLogin[5]);
} else
{
printf("Never logged in\n");
}
@@ -333,7 +324,7 @@ print_login_control ( __u8 *val )
if (a->PasswordExpireDate[2] || a->PasswordExpireDate[1] ||
a->PasswordExpireDate[0])
{
printf("Password expires on: %d.%d.%d\n" ,
printf("Password expires on: %d.%d.%d\n",
a->PasswordExpireDate[2],
a->PasswordExpireDate[1],
a->PasswordExpireDate[0]);
@@ -356,8 +347,7 @@ print_login_control ( __u8 *val )
printf("Maximum no of connections: %d\n",
ntohs(a->MaxConnections));
}
if ( a->MaxDiskUsage != 0xFFFFFF7FL )
if (a->MaxDiskUsage != 0xFFFFFF7FL)
{
printf("Maximum DiskQuota : %8ld blocks\n",
ntohl(a->MaxDiskUsage));
@@ -371,23 +361,22 @@ print_login_control ( __u8 *val )
}
if (a->LastIntruder.NetWork != 0L)
{
printf("Last \'intruder\' address: %s\n" ,
print_station_addr("(%L): %N[%S]" ,
&(a->LastIntruder),buff));
printf("Last \'intruder\' address: %s\n",
print_station_addr("(%L): %N[%S]",
&(a->LastIntruder), buff));
}
if ( a->RestrictionMask & 0xFC )
if (a->RestrictionMask & 0xFC)
{
printf("RestrictionMask : %02X\n", a->RestrictionMask);
}
for ( i = 0 ; i < 42 ; i++ )
for (i = 0; i < 42; i++)
{
if ( a->ConnectionTimeMask[i] != 0xFF )
if (a->ConnectionTimeMask[i] != 0xFF)
{
i = 101;
}
}
if ( i < 100 )
if (i < 100)
{
return;
}
@@ -395,50 +384,79 @@ print_login_control ( __u8 *val )
printf("Time restrictions: 1 1 1 1 1 1 1 1 1 1 2 2 2 2 ]\n");
printf(" Day [0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 ]\n");
for ( i = 0 ; i < 7 ; i++ )
for (i = 0; i < 7; i++)
{
printf (" %s [" , days[i]);
for ( j = 0 ; j < 6 ; j++ )
printf(" %s [", days[i]);
for (j = 0; j < 6; j++)
{
for ( mask = 1 ; mask < 0x100 ; mask <<= 1 )
for (mask = 1; mask < 0x100; mask <<= 1)
{
putchar ( (*val & mask) ? '*' : ' ' ) ;
putchar((*val & mask) ? '*' : ' ');
}
val++ ;
val++;
}
printf ( "]\n" ) ;
printf("]\n");
}
}
void
print_addr( __u8 *val)
print_addr(__u8 * val)
{
char buff[50];
print_station_addr("(%L): %N[%S]",
(struct ncp_station_addr *)val, buff);
(struct ncp_station_addr *) val, buff);
printf("%s\n", buff);
}
static struct {
char *pname ;
void (*func)(__u8 *) ;
} formats[] = {
{ "DESCRIPTION" , print_string } ,
{ "SURNAME" , print_string } ,
{ "OBJECT_CLASS" , print_string } ,
{ "DESCRIPTION" , print_string } ,
{ "IDENTIFICATION" , print_string } ,
{ "Q_DIRECTORY" , print_string } ,
{ "LOGIN_CONTROL" , print_login_control } ,
{ "NET_ADDRESS" , print_addr } ,
{ NULL , NULL }
static struct
{
char *pname;
void (*func) (__u8 *);
}
formats[] =
{
{
"DESCRIPTION", print_string
}
,
{
"SURNAME", print_string
}
,
{
"OBJECT_CLASS", print_string
}
,
{
"DESCRIPTION", print_string
}
,
{
"IDENTIFICATION", print_string
}
,
{
"Q_DIRECTORY", print_string
}
,
{
"LOGIN_CONTROL", print_login_control
}
,
{
"NET_ADDRESS", print_addr
}
,
{
NULL, NULL
}
};
static void
print_property(char *prop_name, __u8 *val, int segments)
print_property(char *prop_name, __u8 * val, int segments)
{
int i;
void (*f)(__u8 *);
void (*f) (__u8 *);
for (i = 0; formats[i].pname != NULL; i++)
{
@@ -454,12 +472,10 @@ print_property(char *prop_name, __u8 *val, int segments)
f(val);
return;
}
for (i = 0; i < segments; i++)
{
printf("Segment: %03d\n", i+1);
print_unknown(&(val[i*128]));
printf("Segment: %03d\n", i + 1);
print_unknown(&(val[i * 128]));
printf("\n");
}
}

148
util/nwfsinfo.c
View File

@@ -1,3 +1,4 @@
/*
* nwfsinfo.c
*
@@ -22,9 +23,9 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"\n"
@@ -37,34 +38,34 @@ help(void)
static void
print_info(struct ncp_file_server_info *info)
{
printf ( "\n" ) ;
printf ( "Fileservername %-48.48s\n" , info->ServerName ) ;
printf ( "\n" ) ;
printf ( "Version %d.%d Revision %c\n" ,
info->FileServiceVersion , info->FileServiceSubVersion,
info->Revision + 'A' ) ;
printf ( "Max. Connections %d\n" ,
info->MaximumServiceConnections ) ;
printf ( "currently in use %d\n" ,
info->ConnectionsInUse ) ;
printf ( "peak connections %d\n" ,
info->MaxConnectionsEverUsed ) ;
printf ( "Max. Volumes %d\n" ,
info->NumberMountedVolumes ) ;
printf ( "SFTLevel %d\n" ,
info->SFTLevel ) ;
printf ( "TTSLevel %d\n" ,
info->TTSLevel ) ;
printf ( "Accountversion %d\n" ,
info->AccountVersion ) ;
printf ( "Queueversion %d\n" ,
info->QueueVersion ) ;
printf ( "Printversion %d\n" ,
info->PrintVersion ) ;
printf ( "Virt.Consolvers. %d\n" ,
info->VirtualConsoleVersion ) ;
printf ( "RestrictionLevel %d\n" ,
info->RestrictionLevel ) ;
printf("\n");
printf("Fileservername %-48.48s\n", info->ServerName);
printf("\n");
printf("Version %d.%d Revision %c\n",
info->FileServiceVersion, info->FileServiceSubVersion,
info->Revision + 'A');
printf("Max. Connections %d\n",
info->MaximumServiceConnections);
printf("currently in use %d\n",
info->ConnectionsInUse);
printf("peak connections %d\n",
info->MaxConnectionsEverUsed);
printf("Max. Volumes %d\n",
info->NumberMountedVolumes);
printf("SFTLevel %d\n",
info->SFTLevel);
printf("TTSLevel %d\n",
info->TTSLevel);
printf("Accountversion %d\n",
info->AccountVersion);
printf("Queueversion %d\n",
info->QueueVersion);
printf("Printversion %d\n",
info->PrintVersion);
printf("Virt.Consolvers. %d\n",
info->VirtualConsoleVersion);
printf("RestrictionLevel %d\n",
info->RestrictionLevel);
printf("\n");
return;
}
@@ -83,75 +84,72 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "h?dti")) != EOF)
{
switch(opt)
switch (opt)
{
case 'h':
case '?':
help();
break;
case 'd':
{
char strings[512];
char *s;
if (ncp_get_file_server_description_strings(conn,
strings)
!= 0)
{
perror("could not get strings");
ncp_close(conn);
return 1;
}
char strings[512];
char *s;
s = strings;
while (s < strings+512)
{
if (strlen(s) == 0)
if (ncp_get_file_server_description_strings(conn,
strings)
!= 0)
{
break;
perror("could not get strings");
ncp_close(conn);
return 1;
}
puts(s);
s += strlen(s)+1;
s = strings;
while (s < strings + 512)
{
if (strlen(s) == 0)
{
break;
}
puts(s);
s += strlen(s) + 1;
}
break;
}
break;
}
case 't':
{
time_t t;
if (ncp_get_file_server_time(conn, &t) != 0)
{
perror("could not get server time");
ncp_close(conn);
return 1;
}
time_t t;
fputs(ctime(&t), stdout);
break;
}
if (ncp_get_file_server_time(conn, &t) != 0)
{
perror("could not get server time");
ncp_close(conn);
return 1;
}
fputs(ctime(&t), stdout);
break;
}
case 'i':
{
struct ncp_file_server_info info;
if (ncp_get_file_server_information(conn, &info) != 0)
{
perror("Could not get server information");
ncp_close(conn);
return 1;
struct ncp_file_server_info info;
if (ncp_get_file_server_information(conn, &info) != 0)
{
perror("Could not get server information");
ncp_close(conn);
return 1;
}
print_info(&info);
break;
}
print_info(&info);
break;
}
default:
usage();
goto finished;
}
}
finished:
finished:
ncp_close(conn);
return 0;
}

24
util/nwfstime.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-s Set file server's time from local time\n"
"\n");
@@ -52,10 +52,9 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "h?s")) != EOF)
{
switch(opt)
switch (opt)
{
case 'h':
case '?':
@@ -70,7 +69,7 @@ main(int argc, char **argv)
}
}
finished:
finished:
if (set != 0)
{
@@ -81,8 +80,7 @@ finished:
ncp_close(conn);
return 1;
}
}
else
} else
{
if ((err = ncp_get_file_server_time(conn, &t)) != 0)
{
@@ -92,7 +90,7 @@ finished:
}
fputs(ctime(&t), stdout);
}
ncp_close(conn);
return 0;
}

29
util/nwgrant.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object added as trustee\n"
"-t type Object type (decimal value)\n"
@@ -60,10 +60,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:r:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -90,22 +90,19 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (rights < 0)
{
fprintf(stderr, "%s: You must specify a rights mask\n",
progname);
goto finished;
}
if (optind != argc-1)
if (optind != argc - 1)
{
fprintf(stderr, "%s: You must specify a directory\n",
progname);
@@ -119,16 +116,14 @@ main(int argc, char *argv[])
progname, object_name);
goto finished;
}
if (ncp_add_trustee(conn, 0, path, o.object_id, rights) != 0)
{
fprintf(stderr, "%s: Could not add trustee rights\n",progname);
fprintf(stderr, "%s: Could not add trustee rights\n", progname);
goto finished;
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}

55
util/nwmsg.c
View File

@@ -41,7 +41,7 @@ main(int argc, char *argv[])
FILE *mtab;
struct mntent *mnt;
long err;
progname = argv[0];
@@ -53,14 +53,12 @@ main(int argc, char *argv[])
progname);
exit(1);
}
mount_point = argv[1];
if ((conn = ncp_open_mount(mount_point, &err)) == NULL)
{
com_err(progname, err, "in ncp_open_mount");
exit(1);
}
if (ncp_get_broadcast_message(conn, message) != 0)
{
fprintf(stderr, "%s: could not get broadcast message\n",
@@ -68,13 +66,11 @@ main(int argc, char *argv[])
ncp_close(conn);
exit(1);
}
if (strlen(message) == 0)
{
syslog(LOG_DEBUG, "no message");
exit(0);
}
#if 0
syslog(LOG_DEBUG, "message: %s", message);
#endif
@@ -87,7 +83,6 @@ main(int argc, char *argv[])
ncp_close(conn);
exit(1);
}
ncp_close(conn);
if ((pwd = getpwuid(info.mounted_uid)) == NULL)
@@ -96,14 +91,12 @@ main(int argc, char *argv[])
progname, info.mounted_uid);
exit(1);
}
if ((mtab = fopen(MOUNTED, "r")) == NULL)
{
fprintf(stderr, "%s: can't open %s\n",
progname, MOUNTED);
exit(1);
}
while ((mnt = getmntent(mtab)) != NULL)
{
if (strcmp(mnt->mnt_dir, mount_point) == 0)
@@ -116,12 +109,10 @@ main(int argc, char *argv[])
{
syslog(LOG_DEBUG, "cannot find mtab entry\n");
}
if (search_utmp(pwd->pw_name, tty) != 0)
{
exit(1);
}
sprintf(tty_path, "/dev/%s", tty);
if ((tty_file = fopen(tty_path, "w")) == NULL)
{
@@ -129,8 +120,7 @@ main(int argc, char *argv[])
progname, tty_path, strerror(errno));
exit(1);
}
fprintf(tty_file,"\r\n\007\007\007Message from NetWare Server: %s\r\n",
fprintf(tty_file, "\r\n\007\007\007Message from NetWare Server: %s\r\n",
mnt->mnt_fsname);
fprintf(tty_file, "%s\r\n", message);
fclose(tty_file);
@@ -145,21 +135,22 @@ main(int argc, char *argv[])
* and the access time
*/
static int
term_chk(char *tty, int *msgsokP, time_t *atimeP, int *showerror)
term_chk(char *tty, int *msgsokP, time_t * atimeP, int *showerror)
{
struct stat s;
char path[MAXPATHLEN];
(void)sprintf(path, "/dev/%s", tty);
if (stat(path, &s) < 0) {
(void) sprintf(path, "/dev/%s", tty);
if (stat(path, &s) < 0)
{
if (showerror)
(void)fprintf(stderr,
"write: %s: %s\n", path, strerror(errno));
return(1);
(void) fprintf(stderr,
"write: %s: %s\n", path, strerror(errno));
return (1);
}
*msgsokP = (s.st_mode & (S_IWRITE >> 3)) != 0; /* group write bit */
*atimeP = s.st_atime;
return(0);
return (0);
}
/*
@@ -182,19 +173,20 @@ search_utmp(char *user, char *tty)
char atty[sizeof(u.ut_line) + 1];
if ((ufd = open(_PATH_UTMP, O_RDONLY)) < 0) {
if ((ufd = open(_PATH_UTMP, O_RDONLY)) < 0)
{
perror("utmp");
return -1;
}
nloggedttys = nttys = 0;
bestatime = 0;
user_is_me = 0;
while (read(ufd, (char *) &u, sizeof(u)) == sizeof(u))
if (strncmp(user, u.ut_name, sizeof(u.ut_name)) == 0) {
if (strncmp(user, u.ut_name, sizeof(u.ut_name)) == 0)
{
++nloggedttys;
(void)strncpy(atty, u.ut_line, sizeof(u.ut_line));
(void) strncpy(atty, u.ut_line, sizeof(u.ut_line));
atty[sizeof(u.ut_line)] = '\0';
if (term_chk(atty, &msgsok, &atime, 0))
@@ -202,19 +194,20 @@ search_utmp(char *user, char *tty)
if (!msgsok)
continue; /* skip ttys with msgs off */
if (u.ut_type != USER_PROCESS)
continue; /* it's not a valid entry */
if (u.ut_type != USER_PROCESS)
continue; /* it's not a valid entry */
++nttys;
if (atime > bestatime) {
if (atime > bestatime)
{
bestatime = atime;
(void)strcpy(tty, atty);
(void) strcpy(tty, atty);
}
}
(void)close(ufd);
if (nloggedttys == 0) {
(void)fprintf(stderr, "write: %s is not logged in\n", user);
(void) close(ufd);
if (nloggedttys == 0)
{
(void) fprintf(stderr, "write: %s is not logged in\n", user);
return -1;
}
return 0;

69
util/nwpasswd.c
View File

@@ -22,16 +22,17 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-U username Username sent to server\n"
"-O objectname Object name to change, default username\n"
"-t type Object type (decimal value)\n"
"\n");
}
int
main(int argc, char *argv[])
@@ -39,27 +40,33 @@ main(int argc, char *argv[])
struct ncp_conn_spec *spec;
struct ncp_conn *conn;
char *server = NULL;
char *user_name = NULL;
char *object_name = NULL;
int object_type = NCP_BINDERY_USER;
unsigned char ncp_key[8];
struct ncp_bindery_object user;
unsigned char buf_obj_name[50];
long err;
char *str;
char oldpass[200], newpass1[200], newpass2[200];
int opt;
progname = argv[0];
while ((opt = getopt(argc, argv, "h?S:U:t:")) != EOF)
while ((opt = getopt(argc, argv, "h?S:U:O:t:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'S':
server = optarg;
break;
case 'U':
user_name = optarg;
break;
case 'O':
object_name = optarg;
break;
case 't':
@@ -74,8 +81,7 @@ main(int argc, char *argv[])
exit(1);
}
}
spec = ncp_find_conn_spec(server, object_name, "",
spec = ncp_find_conn_spec(server, user_name, "",
1, getuid(), &err);
if (spec == NULL)
@@ -83,13 +89,29 @@ main(int argc, char *argv[])
com_err(argv[0], err, "trying to find server");
exit(1);
}
if (!object_name)
{
object_name = spec->user;
} else
{
strcpy(buf_obj_name, object_name);
object_name = buf_obj_name;
str_upper(object_name);
}
spec->login_type = object_type;
printf("Changing password for user %s on server %s\n",
spec->user, spec->server);
object_name, spec->server);
str = getpass("Enter old password: ");
if (object_name == spec->user)
{
str = getpass("Enter old password: ");
} else
{
char sx[80];
sprintf(sx, "Enter password for %s: ", spec->user);
str = getpass(sx);
}
if (strlen(str) >= sizeof(oldpass))
{
printf("Password too long\n");
@@ -122,7 +144,6 @@ main(int argc, char *argv[])
printf("You mistype the new password, try again\n");
exit(1);
}
strcpy(spec->password, oldpass);
if ((conn = ncp_open(spec, &err)) == NULL)
@@ -130,16 +151,26 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when trying to open connection");
exit(1);
}
if ( ((err = ncp_get_encryption_key(conn, ncp_key)) != 0)
|| ((err = ncp_get_bindery_object_id(conn, 1, spec->user,
if (object_name != spec->user)
{
if (!(err = ncp_get_bindery_object_id(conn, 1, spec->user,
&user))
&& !(err = ncp_login_user(conn, spec->user, oldpass)))
{
*oldpass = '\0';
} else
{
com_err(argv[0], err, "not own password");
}
}
if (((err = ncp_get_encryption_key(conn, ncp_key)) != 0)
|| ((err = ncp_get_bindery_object_id(conn, 1, object_name,
&user)) != 0)
|| ((err = ncp_change_login_passwd(conn, &user, ncp_key,
oldpass, newpass1)) != 0))
oldpass, newpass1)) != 0))
{
com_err(argv[0], err, "trying to change password");
}
ncp_close(conn);
return 0;
}

26
util/nwrevoke.c
View File

@@ -22,15 +22,15 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-o object_name Name of object removed as trustee\n"
"-t type Object type (decimal value)\n"
@@ -58,10 +58,10 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?o:t:")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'o':
object_name = optarg;
str_upper(object_name);
@@ -85,15 +85,13 @@ main(int argc, char *argv[])
argv[0]);
goto finished;
}
if (object_name == NULL)
{
fprintf(stderr, "%s: You must specify an object name\n",
argv[0]);
goto finished;
}
if (optind != argc-1)
if (optind != argc - 1)
{
fprintf(stderr, "%s: You must specify a directory\n",
progname);
@@ -107,17 +105,15 @@ main(int argc, char *argv[])
progname, object_name);
goto finished;
}
if (ncp_delete_trustee(conn, 0, path, o.object_id) != 0)
{
fprintf(stderr, "%s: Could not remove trustee rights\n",
progname);
goto finished;
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}

41
util/nwrights.c
View File

@@ -22,9 +22,9 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options] file/directory\n", progname);
printf("\n"
"-h Print this help text\n"
"\n"
"file/directory\n"
@@ -45,7 +45,8 @@ main(int argc, char *argv[])
while ((opt = getopt(argc, argv, "h?")) != EOF)
{
switch(opt) {
switch (opt)
{
case 'h':
case '?':
help();
@@ -61,18 +62,15 @@ main(int argc, char *argv[])
usage();
goto finished;
}
if (optind == argc-1)
if (optind == argc - 1)
{
path = argv[optind];
}
if ((conn = ncp_open_mount(path, &err)) == NULL)
{
com_err(argv[0], err, "when initializing");
goto finished;
}
if ((err = ncp_get_eff_directory_rights(conn, 0, 0, 0x8006,
conn->i.volume_number,
conn->i.directory_id, NULL,
@@ -81,61 +79,52 @@ main(int argc, char *argv[])
com_err(argv[0], err, "when finding rights");
goto finished;
}
printf("Your effective rights for %s are: [%c%c%c%c%c%c%c%c]\n",
path,
((rights & NCP_PERM_SUPER ) != 0) ? 'S' : ' ',
((rights & NCP_PERM_READ ) != 0) ? 'R' : ' ',
((rights & NCP_PERM_WRITE ) != 0) ? 'W' : ' ',
((rights & NCP_PERM_SUPER) != 0) ? 'S' : ' ',
((rights & NCP_PERM_READ) != 0) ? 'R' : ' ',
((rights & NCP_PERM_WRITE) != 0) ? 'W' : ' ',
((rights & NCP_PERM_CREATE) != 0) ? 'C' : ' ',
((rights & NCP_PERM_DELETE) != 0) ? 'E' : ' ',
((rights & NCP_PERM_MODIFY) != 0) ? 'M' : ' ',
((rights & NCP_PERM_SEARCH) != 0) ? 'F' : ' ',
((rights & NCP_PERM_OWNER ) != 0) ? 'A' : ' ');
((rights & NCP_PERM_OWNER) != 0) ? 'A' : ' ');
if ((rights & NCP_PERM_SUPER ) != 0)
if ((rights & NCP_PERM_SUPER) != 0)
{
printf("(S): You have SUPERVISOR rights\n");
}
if ((rights & NCP_PERM_READ ) != 0)
if ((rights & NCP_PERM_READ) != 0)
{
printf("(R): You may READ from files\n");
}
if ((rights & NCP_PERM_WRITE ) != 0)
if ((rights & NCP_PERM_WRITE) != 0)
{
printf("(W): You may WRITE to files\n");
}
if ((rights & NCP_PERM_CREATE) != 0)
{
printf("(C): You may CREATE files\n");
}
if ((rights & NCP_PERM_DELETE) != 0)
{
printf("(E): You may ERASE files\n");
}
if ((rights & NCP_PERM_MODIFY) != 0)
{
printf("(M): You may MODIFY directory\n");
}
if ((rights & NCP_PERM_SEARCH) != 0)
{
printf("(F): You may SCAN for files\n");
}
if ((rights & NCP_PERM_OWNER ) != 0)
if ((rights & NCP_PERM_OWNER) != 0)
{
printf("(A): You may change ACCESS control\n");
}
result = 0;
finished:
finished:
ncp_close(conn);
return result;
}

159
util/nwtrustee.c Normal file
View File

@@ -0,0 +1,159 @@
/*
* nwtrustee.c
*
* List Trustees
*
* Copyright (C) 1996 by Volker Lendecke
*
*/
#include <stdio.h>
#include <unistd.h>
#include <ctype.h>
#include <stdlib.h>
#include "ncplib.h"
static char *progname;
static void
usage(void)
{
fprintf(stderr, "usage: %s [options] pattern\n", progname);
return;
}
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-l volumeid Volume id to be searched\n"
"-L volname Volume name insteed of id\n"
"-o objectid Object id\n"
"-O objname Object name ( type must be specified )\n"
"-t type Object type\n"
"-v Verbose listing\n"
"\n");
}
int
fromhex(char c)
{
c -= '0';
if (c > 9)
c = toupper(c) + '0' - 'A' + 10;
return c & 15;
}
int
main(int argc, char **argv)
{
struct ncp_conn *conn;
struct ncp_bindery_object bobj;
char ppath[256];
char *p;
long err;
int opt, vid, type = 1;
int verbose = 0;
__u32 oid = 1;
__u16 nextp, trust;
progname = argv[0];
if ((conn = ncp_initialize(&argc, argv, 1, &err)) == NULL)
{
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "h?vl:L:o:O:t:")) != EOF)
{
switch (opt)
{
case 'h':
case '?':
help();
exit(1);
case 'l':
vid = atoi(optarg);
break;
case 'L':
if (ncp_get_volume_number(conn, optarg, &vid))
{
ncp_close(conn);
return 1;
}
break;
case 'o':
oid = 0;
while (*optarg)
{
oid = (oid << 4) | fromhex(*optarg);
optarg++;
}
break;
case 'O':
for (p = optarg; *p != 0; p++)
{
*p = toupper(*p);
}
if (ncp_get_bindery_object_id(conn, type, optarg, &bobj))
{
ncp_close(conn);
return 1;
}
oid = bobj.object_id;
break;
case 'v':
verbose = 1;
break;
case 't':
type = atoi(optarg);
break;
default:
usage();
exit(1);
}
}
if (optind < argc)
{
usage();
exit(1);
}
nextp = 0;
while (!ncp_get_trustee(conn, oid, vid, ppath, &trust, &nextp))
{
if (!nextp)
break;
printf("%s ", ppath);
if (verbose)
{
strcpy(ppath, "[ R W O C E A F M ]");
p = ppath + 2;
for (type = 1; type < 256; type <<= 1)
{
if (!(trust & type))
*p = ' ';
p += 2;
}
printf("%s\n", ppath);
} else
{
printf("%X\n", trust);
}
}
ncp_close(conn);
return 0;
}

19
util/nwuserlist.c
View File

@@ -34,9 +34,9 @@ str_trim_right(char *s, char c)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-a Print Station's addr\n"
@@ -62,10 +62,9 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
goto finished;
}
while ((opt = getopt(argc, argv, "h?a")) != EOF)
{
switch(opt)
switch (opt)
{
case 'h':
case '?':
@@ -86,7 +85,6 @@ main(int argc, char **argv)
ncp_close(conn);
return 1;
}
if (isatty(1))
{
if (print_addr == 0)
@@ -97,8 +95,7 @@ main(int argc, char **argv)
"Conn",
"User name",
"Login time");
}
else
} else
{
printf("\n%-6s%-21s%-27s%-12s\n"
"---------------------------------------------"
@@ -109,7 +106,6 @@ main(int argc, char **argv)
"Login time");
}
}
for (i = 1; i <= info.MaximumServiceConnections; i++)
{
char name[49];
@@ -127,17 +123,16 @@ main(int argc, char **argv)
{
struct sockaddr_ipx addr;
__u8 conn_type;
memset(&addr, 0, sizeof(addr));
ncp_get_internet_address(conn, i, &addr, &conn_type);
ipx_print_saddr(&addr);
printf(" ");
}
printf("%s", ctime(&login_time));
}
finished:
finished:
ncp_close(conn);
return 0;
}

119
util/nwvolinfo.c Normal file
View File

@@ -0,0 +1,119 @@
/*
* nwvolinfo.c
*
* Volume Information
*
* Copyright (C) 1996 by Volker Lendecke
*
*/
#include <stdio.h>
#include <unistd.h>
#include <ctype.h>
#include <stdlib.h>
#include "ncplib.h"
static char *progname;
static void
usage(void)
{
fprintf(stderr, "usage: %s [options] pattern\n", progname);
return;
}
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-h Print this help text\n"
"-S server Server name to be used\n"
"-U username Username sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"\n"
"-v volume volume name\n"
"-N Numeric format\n"
"\n");
}
int
main(int argc, char **argv)
{
struct ncp_conn *conn;
struct ncp_volume_info o;
char *volname = "SYS";
long err;
int opt;
int numk;
__u16 type = 0;
progname = argv[0];
if ((conn = ncp_initialize(&argc, argv, 1, &err)) == NULL)
{
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "h?Nv:")) != EOF)
{
switch (opt)
{
case 'h':
case '?':
help();
exit(1);
case 'N':
type = 1;
break;
case 'v':
volname = optarg;
break;
default:
usage();
exit(1);
}
}
if (optind < argc)
{
usage();
exit(1);
}
if (ncp_get_volume_number(conn, volname, &opt))
{
exit(1);
}
if (ncp_get_volume_info_with_number(conn, opt, &o))
{
exit(1);
}
numk = o.sectors_per_block / 2;
o.free_blocks += o.purgeable_blocks;
if (type)
{
printf("%d %d %d %d %d %d\n",
o.total_blocks * numk,
o.free_blocks * numk,
o.purgeable_blocks * numk,
o.not_yet_purgeable_blocks * numk,
o.total_dir_entries,
o.available_dir_entries);
} else
{
printf("Total : %dK\n", o.total_blocks * numk);
printf("Free : %dK\n", o.free_blocks * numk);
printf("Purgable : %dK\n", o.purgeable_blocks * numk);
printf("No Purg. : %dK\n", o.not_yet_purgeable_blocks * numk);
printf("Dirs : %d\n", o.total_dir_entries);
printf("Free dirs: %d\n", o.available_dir_entries);
}
ncp_close(conn);
return 0;
}

7
util/pqlist.c
View File

@@ -29,18 +29,15 @@ main(int argc, char **argv)
com_err(argv[0], err, "when initializing");
return 1;
}
if (argc > 2)
{
fprintf(stderr, "usage: %s [options] [pattern]\n", argv[0]);
return 1;
}
if (argc == 2)
{
pattern = argv[1];
}
for (p = pattern; *p != '\0'; p++)
{
*p = toupper(*p);
@@ -55,7 +52,6 @@ main(int argc, char **argv)
"Print queue name",
"Queue ID");
}
q.object_id = 0xffffffff;
while (ncp_scan_bindery_object(conn, q.object_id,
@@ -63,14 +59,13 @@ main(int argc, char **argv)
{
found = 1;
printf("%-52s", q.object_name);
printf("%08X\n", (unsigned int)q.object_id);
printf("%08X\n", (unsigned int) q.object_id);
}
if ((found == 0) && (isatty(1)))
{
printf("No queues found\n");
}
ncp_close(conn);
return 0;
}

93
util/pserver.c
View File

@@ -18,7 +18,8 @@
#include <signal.h>
#include "ncplib.h"
struct nw_queue {
struct nw_queue
{
struct ncp_conn *conn;
char queue_name[NCP_BINDERY_NAME_LEN];
@@ -34,11 +35,11 @@ static int term_request;
static char *progname;
static int
init_queue(struct ncp_conn *conn, char *queue_name,
char *command, struct nw_queue *q);
init_queue(struct ncp_conn *conn, char *queue_name,
char *command, struct nw_queue *q);
static int
poll_queue(struct nw_queue *q);
poll_queue(struct nw_queue *q);
static void
usage(void)
@@ -50,20 +51,20 @@ usage(void)
static void
help(void)
{
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
printf("\n");
printf("usage: %s [options]\n", progname);
printf("\n"
"-S server Server name to be used\n"
"-U username Print Server name sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-q queue name Name of the printing queue to use\n"
"-U username Print Server name sent to server\n"
"-P password Use this password\n"
"-n Do not use any password\n"
"-C Don't convert password to uppercase\n"
"-q queue name Name of the printing queue to use\n"
"-c command Name of print command, default: 'lpr'\n"
"-j job type Type of job (Form number) to service\n"
"-t timeout Polling interval, default: 30 sec\n"
"-d Debug: don't daemonize\n"
"-h print this help text\n"
"-h print this help text\n"
"\n");
}
@@ -74,9 +75,9 @@ help(void)
static void
terminate_handler()
{
signal(SIGTERM,terminate_handler);
signal(SIGTERM, terminate_handler);
signal(SIGINT, terminate_handler);
term_request=1;
term_request = 1;
}
/* Daemon_init is taken from Stevens, Adv. Unix programming */
@@ -88,12 +89,10 @@ daemon_init(void)
if ((pid = fork()) < 0)
{
return -1;
}
else if (pid != 0)
} else if (pid != 0)
{
exit(0); /* parent vanishes */
}
/* child process */
setsid();
chdir("/");
@@ -124,7 +123,7 @@ main(int argc, char *argv[])
for (i = 1; i < argc; i += 1)
{
if ( (strcmp(argv[i], "-h") == 0)
if ((strcmp(argv[i], "-h") == 0)
|| (strcmp(argv[i], "-?") == 0))
{
help();
@@ -146,14 +145,12 @@ main(int argc, char *argv[])
daemon_init();
openlog("pserver", LOG_PID, LOG_LPR);
}
if ((conn = ncp_initialize_as(&argc, argv, 1,
NCP_BINDERY_PSERVER, &err)) == NULL)
{
com_err(argv[0], err, "when initializing");
return 1;
}
while ((opt = getopt(argc, argv, "q:c:j:t:dh")) != EOF)
{
switch (opt)
@@ -186,7 +183,6 @@ main(int argc, char *argv[])
usage();
return -1;
}
memzero(q);
if (queue_name == NULL)
@@ -194,28 +190,25 @@ main(int argc, char *argv[])
fprintf(stderr, "You must specify a queue\n");
return 1;
}
if (init_queue(conn, queue_name, command, &q) != 0)
{
perror("Could not init queue");
ncp_close(conn);
return 1;
}
q.job_type = job_type;
term_request = 0;
signal(SIGTERM,terminate_handler);
signal(SIGTERM, terminate_handler);
signal(SIGINT, terminate_handler);
while (1)
{
if ( (poll_queue(&q) != 0)
if ((poll_queue(&q) != 0)
&& (term_request == 0))
{
continue;
}
if (term_request != 0)
{
break;
@@ -239,14 +232,13 @@ init_queue(struct ncp_conn *conn, char *queue_name, char *command,
q->conn = conn;
q->command = command;
if (ncp_get_bindery_object_id(conn, NCP_BINDERY_PQUEUE,
queue_name, &obj) != 0)
{
fprintf(stderr, "Queue %s not found\n", queue_name);
return -1;
}
q->queue_id = obj.object_id;
memcpy(q->queue_name, obj.object_name, sizeof(q->queue_name));
@@ -258,26 +250,26 @@ init_queue(struct ncp_conn *conn, char *queue_name, char *command,
}
return 0;
}
void
build_command(struct nw_queue *q, struct queue_job *j,
char *target, int target_size)
{
char *s = q->command;
char *target_end = target+target_size;
char *target_end = target + target_size;
void add_string(char *s)
{
int len = strlen(s);
if (target + len + 1 > target_end)
{
int len = strlen(s);
if (target + len + 1 > target_end)
{
len = target_end - target - 1;
}
strncpy(target, s, len);
target += len;
len = target_end - target - 1;
}
strncpy(target, s, len);
target += len;
}
memset(target, 0, target_size);
@@ -290,8 +282,7 @@ build_command(struct nw_queue *q, struct queue_job *j,
s += 1;
continue;
}
switch (*(s+1))
switch (*(s + 1))
{
case '%':
*target = '%';
@@ -305,8 +296,7 @@ build_command(struct nw_queue *q, struct queue_job *j,
== 0)
{
user = u.object_name;
}
else
} else
{
user = "*UNKNOWN USER*";
}
@@ -314,7 +304,7 @@ build_command(struct nw_queue *q, struct queue_job *j,
}
default:
*target = '%';
*(target+1) = *(s+1);
*(target + 1) = *(s + 1);
target += 2;
}
s += 2;
@@ -322,7 +312,7 @@ build_command(struct nw_queue *q, struct queue_job *j,
}
static int
poll_queue(struct nw_queue *q)
@@ -337,19 +327,16 @@ poll_queue(struct nw_queue *q)
/* No job for us */
return 0;
}
if (pipe(fd) < 0)
{
syslog(LOG_ERR, "pipe error: %m");
goto fail;
}
if ((pid = fork()) < 0)
{
syslog(LOG_ERR, "fork error: %m");
goto fail;
}
if (pid > 0)
{
/* parent */
@@ -375,8 +362,7 @@ poll_queue(struct nw_queue *q)
{
syslog(LOG_ERR, "waitpid: %m\n");
}
}
else
} else
{
/* child */
@@ -394,7 +380,6 @@ poll_queue(struct nw_queue *q)
}
close(fd[0]);
}
build_command(q, &job, command, sizeof(command));
execl("/bin/sh", "sh", "-c", command, NULL);
@@ -403,10 +388,10 @@ poll_queue(struct nw_queue *q)
exit(1);
}
ncp_finish_servicing_job(q->conn, q->queue_id, job.j.JobNumber,0);
return 1;
ncp_finish_servicing_job(q->conn, q->queue_id, job.j.JobNumber, 0);
return 1;
fail:
fail:
ncp_abort_servicing_job(q->conn, q->queue_id, job.j.JobNumber);
/* We tell that we did not have a job to avoid overloading
when something's wrong */

8
util/slist.c
View File

@@ -30,12 +30,10 @@ main(int argc, char *argv[])
printf("usage: %s [pattern]\n", argv[0]);
exit(1);
}
if (argc == 2)
{
pattern = argv[1];
}
for (p = pattern; *p != '\0'; p++)
{
*p = toupper(*p);
@@ -46,7 +44,6 @@ main(int argc, char *argv[])
com_err(argv[0], err, "in ncp_open");
exit(1);
}
if (isatty(1))
{
printf("\n%-52s%-10s%-12s\n"
@@ -56,7 +53,6 @@ main(int argc, char *argv[])
"Network",
"Node Address");
}
obj.object_id = 0xffffffff;
while (ncp_scan_bindery_object(conn, obj.object_id,
@@ -65,7 +61,7 @@ main(int argc, char *argv[])
{
struct nw_property prop;
struct prop_net_address *naddr
= (struct prop_net_address *)&prop;
= (struct prop_net_address *) &prop;
found = 1;
@@ -86,7 +82,5 @@ main(int argc, char *argv[])
{
printf("No servers found\n");
}
ncp_close(conn);
}