int
ncp_change_obj_passwd(NWCONN_HANDLE connid,
const struct ncp_bindery_object *object,
const u_char *key,
const u_char *oldpasswd,
const u_char *newpasswd)
{
long id = htonl(object->object_id);
u_char cryptkey[8];
u_char newpwd[16]; /* new passwd as stored by server */
u_char oldpwd[16]; /* old passwd as stored by server */
u_char len;
DECLARE_RQ;
memcpy(cryptkey, key, 8);
nw_keyhash((u_char *)&id, oldpasswd, strlen(oldpasswd), oldpwd);
nw_keyhash((u_char *)&id, newpasswd, strlen(newpasswd), newpwd);
nw_encrypt(cryptkey, oldpwd, cryptkey);
nw_passencrypt(oldpwd, newpwd, newpwd);
nw_passencrypt(oldpwd + 8, newpwd + 8, newpwd + 8);
if ((len = strlen(newpasswd)) > 63) {
len = 63;
}
len = ((len ^ oldpwd[0] ^ oldpwd[1]) & 0x7f) | 0x40;
ncp_init_request_s(conn, 75);
ncp_add_mem(conn, cryptkey, 8);
ncp_add_word_hl(conn, object->object_type);
ncp_add_pstring(conn, object->object_name);
ncp_add_byte(conn, len);
ncp_add_mem(conn, newpwd, 16);
return ncp_request(connid, 23, conn);
}
NWCCODE
ncp_ns_search_entry_set(NWCONN_HANDLE conn,
unsigned int search_attributes,
const char* pattern,
unsigned int datastream,
u_int32_t rim,
int* more,
size_t *itemcount,
struct ncp_search_seq* seq,
void* buffer, size_t* size) {
size_t slen;
NWCCODE result;
ncp_init_request(conn);
ncp_add_byte(conn, 0x14);
ncp_add_byte(conn, seq->name_space);
ncp_add_byte(conn, datastream);
ncp_add_word_lh(conn, search_attributes);
ncp_add_dword_lh(conn, rim);
ncp_add_word_lh(conn, *itemcount);
ncp_add_mem(conn, &seq->s, 9);
slen = pattern ? strlen(pattern) : 0;
ncp_add_byte(conn, slen);
if (slen)
ncp_add_mem(conn, pattern, slen);
result = ncp_request(conn, 0x57);
if (result) {
ncp_unlock_conn(conn);
return result;
}
if (conn->ncp_reply_size < 9 + 1 + 2) {
ncp_unlock_conn(conn);
return NWE_INVALID_NCP_PACKET_LENGTH;
}
memcpy(&seq->s, ncp_reply_data(conn, 0), 9);
*more = ncp_reply_byte(conn, 9);
*itemcount = ncp_reply_word_lh(conn, 10);
slen = conn->ncp_reply_size - 9 - 1 - 2;
if (slen > *size) {
slen = *size;
result = NWE_BUFFER_OVERFLOW;
} else
*size = slen;
memcpy(buffer, ncp_reply_data(conn, 12), slen);
ncp_unlock_conn(conn);
return result;
}
void
ncp_add_pstring(struct ncp_buf *conn, const char *s) {
int len = strlen(s);
if (len > 255) {
ncp_printf("ncp_add_pstring: string too long: %s\n", s);
len = 255;
}
ncp_add_byte(conn, len);
ncp_add_mem(conn, s, len);
return;
}
static NWCCODE ncp_log_physical_record32(NWCONN_HANDLE conn, const char fh[6],
u_int32_t startOffset, u_int32_t length, unsigned int flags,
unsigned int timeout) {
NWCCODE err;
ncp_init_request(conn);
ncp_add_byte(conn, flags);
ncp_add_mem(conn, fh, 6);
ncp_add_dword_hl(conn, startOffset);
ncp_add_dword_hl(conn, length);
ncp_add_word_hl(conn, timeout);
err = ncp_request(conn, 109);
ncp_unlock_conn(conn);
return err;
}
static NWCCODE ncp_clear_release_physical_record32(NWCONN_HANDLE conn, const char fh[6],
u_int32_t startOffset, u_int32_t length, int release) {
NWCCODE err;
ncp_init_request(conn);
ncp_add_mem(conn, fh, 6);
ncp_add_dword_hl(conn, startOffset);
ncp_add_dword_hl(conn, length);
if (release) {
err = ncp_request(conn, 28);
} else {
err = ncp_request(conn, 30);
}
ncp_unlock_conn(conn);
return err;
}
int
ncp_keyed_verify_password(NWCONN_HANDLE cH, char *key, char *passwd,
struct ncp_bindery_object *objinfo)
{
u_long id = htonl(objinfo->object_id);
u_char cryptkey[8];
u_char buf[128];
DECLARE_RQ;
nw_keyhash((u_char *)&id, passwd, strlen(passwd), buf);
nw_encrypt(key, buf, cryptkey);
ncp_init_request_s(conn, 74);
ncp_add_mem(conn, cryptkey, sizeof(cryptkey));
ncp_add_word_hl(conn, objinfo->object_type);
ncp_add_pstring(conn, objinfo->object_name);
return ncp_request(cH, 23, conn);
}
NWCCODE
NWRequest(NWCONN_HANDLE cH, nuint16 fn,
nuint16 nrq, NW_FRAGMENT* rq,
nuint16 nrp, NW_FRAGMENT* rp)
{
int error;
struct ncp_conn_frag nf;
DECLARE_RQ;
ncp_init_request(conn);
ncp_add_byte(conn, NCP_CONN_FRAG);
nf.fn = fn;
nf.rqfcnt = nrq;
nf.rqf = rq;
nf.rpf = rp;
nf.rpfcnt = nrp;
ncp_add_mem(conn, &nf, sizeof(nf));
error = ncp_conn_request(cH, conn);
return error;
}
