mars_nwe/mars-dosutils
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
50524cf7590089f254bc1420af1105af2d40ab1c
mars-dosutils/flagdir.c
Mario Fetka 50524cf759 dosutils: add GPL-2 headers and file descriptions 
Add GPL-2-or-later license headers to the DOS utility source files and
document the purpose and local dependencies of each C, header and assembler
file.

Preserve the original Martin Stover copyright attribution for the historic
MARS-NWE utility sources, including files that did not previously carry an
explicit header but are part of the original tool set. Add Mario Fetka as the
2026 copyright holder for the current maintenance work, and use Mario-only
headers for files without original Martin Stover ownership.

Also add a root-level COPYING file containing the GPL-2 license text.
2026-05-29 08:07:09 +02:00

623 lines
14 KiB
C
Raw Blame History

/*
* mars-nwe-dosutils - NetWare/DOS utility tools.
*
* Copyright (C) 2026 Mario Fetka
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* Purpose: FLAGDIR utility for displaying and changing NetWare directory attributes.
* Depends on: net.h, c32ncp.h, netcall.c requester helpers, c32ncp.c namespace/NCP helpers, tools.c shared utility routines.
*/
/* flagdir.c - Novell FLAGDIR-like DOS utility, Client32 version */
#include "net.h"
#include "c32ncp.h"
#include <dos.h>
#include <direct.h>
#define FD_NWFA_H 0x00000002UL
#define FD_NWFA_SY 0x00000004UL
#define FD_NWFA_P 0x00010000UL
#define FD_NWFA_RI 0x00020000UL
#define FD_NWFA_DI 0x00040000UL
#define FD_DIR_BITS (FD_NWFA_H | FD_NWFA_SY | FD_NWFA_P | FD_NWFA_RI | FD_NWFA_DI)
#define FD_DM_ATTRIBUTES 0x00000002UL
#ifndef _A_RDONLY
#define _A_RDONLY 0x01
#endif
#ifndef _A_HIDDEN
#define _A_HIDDEN 0x02
#endif
#ifndef _A_SYSTEM
#define _A_SYSTEM 0x04
#endif
#ifndef _A_SUBDIR
#define _A_SUBDIR 0x10
#endif
#ifndef _A_ARCH
#define _A_ARCH 0x20
#endif
static void fd_put_dword_lh(uint8 *p, uint32 v)
{
p[0] = (uint8)(v & 0xff);
p[1] = (uint8)((v >> 8) & 0xff);
p[2] = (uint8)((v >> 16) & 0xff);
p[3] = (uint8)((v >> 24) & 0xff);
}
static uint32 fd_get_dword_lh(uint8 *p)
{
return((uint32)p[0] |
((uint32)p[1] << 8) |
((uint32)p[2] << 16) |
((uint32)p[3] << 24));
}
static int fd_copy_ncp22_name(uint8 *dst, char *src, uint8 *len_out)
{
char tmp[260];
int len;
if (!dst || !len_out)
return(-1);
if (!src)
src = "";
tool_upcopy(tmp, src, sizeof(tmp));
if (strchr(tmp, '\\') || strchr(tmp, '/') || strchr(tmp, ':'))
return(-1);
len = strlen(tmp);
if (len < 1 || len > 12)
return(-1);
memcpy(dst, tmp, len);
*len_out = (uint8)len;
return(0);
}
static int fd_ncp22_1e_obtain_attrs(char *name, uint32 *attrs)
{
struct {
uint16 len;
uint8 func;
uint8 dirhandle;
uint8 search_attributes;
uint8 searchsequence[4];
uint8 namlen;
uint8 name[12];
} req;
struct {
uint16 len;
uint8 data[128];
} repl;
uint8 connid = 0;
uint8 dhandle = 0;
uint8 namlen = 0;
if (tool_current_dhandle(&connid, &dhandle))
return(-1);
memset(&req, 0, sizeof(req));
memset(&repl, 0, sizeof(repl));
if (fd_copy_ncp22_name(req.name, name, &namlen))
return(-1);
req.func = 0x1e; /* Scan directory */
req.dirhandle = dhandle;
req.search_attributes = 0x16; /* hidden/system/subdir */
U32_TO_BE32(0xffffffffUL, req.searchsequence);
req.namlen = namlen;
req.len = (uint16)(1 + 1 + 1 + 4 + 1 + namlen);
repl.len = sizeof(repl.data);
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno)
return(-1);
/* NCP22/30 Scan Directory returns attributes at offset 8. */
if (attrs)
*attrs = fd_get_dword_lh(repl.data + 8);
return(0);
}
static int fd_ncp22_25_modify_attrs(char *name, uint32 attrs)
{
struct {
uint16 len;
uint8 func;
uint8 dirhandle;
uint8 search_attributes;
uint8 searchsequence[4];
uint8 change_bits[4];
uint8 subdir[4];
uint8 attributes[4];
uint8 uniqueid;
uint8 flags;
uint8 namespace;
uint8 namlen;
uint8 name[12];
uint8 rest[104];
} req;
struct {
uint16 len;
} repl;
uint8 connid = 0;
uint8 dhandle = 0;
if (tool_current_dhandle(&connid, &dhandle))
return(-1);
memset(&req, 0, sizeof(req));
memset(&repl, 0, sizeof(repl));
req.func = 0x25; /* Set directory/file information */
req.dirhandle = dhandle;
req.search_attributes = 0x16; /* hidden/system/subdir */
U32_TO_BE32(0xffffffffUL, req.searchsequence);
U32_TO_32(FD_DM_ATTRIBUTES, req.change_bits);
fd_put_dword_lh(req.attributes, attrs);
if (fd_copy_ncp22_name(req.name, name, &req.namlen))
return(-1);
req.len = sizeof(req) - sizeof(req.len);
neterrno = Net_Call(0xE200, &req, &repl);
if (neterrno)
return(-1);
return(0);
}
static char *fd_last_sep(char *s)
{
char *last = NULL;
char *p;
for (p = s; *p; p++) {
if (*p == '\\' || *p == '/' || *p == ':')
last = p;
}
return(last);
}
static void fd_split_pattern(char *pattern, char *parent, int parent_size,
char *leaf, int leaf_size)
{
char temp[260];
char *sep;
int plen;
parent[0] = '\0';
leaf[0] = '\0';
strmaxcpy(temp, pattern, sizeof(temp) - 1);
sep = fd_last_sep(temp);
if (!sep) {
strmaxcpy(leaf, temp, leaf_size - 1);
return;
}
if (*(sep + 1))
strmaxcpy(leaf, sep + 1, leaf_size - 1);
else
strmaxcpy(leaf, "*.*", leaf_size - 1);
plen = (int)(sep - temp);
if (*sep == ':' && (*(sep + 1) == '\\' || *(sep + 1) == '/'))
plen += 2;
else if (*sep == ':' || *sep == '\\' || *sep == '/')
plen += 1;
if (plen >= parent_size)
plen = parent_size - 1;
memcpy(parent, temp, plen);
parent[plen] = '\0';
}
static int fd_enter_parent(char *pattern, char *leaf, int leaf_size,
char *oldcwd, int oldcwd_size)
{
char parent[260];
oldcwd[0] = '\0';
fd_split_pattern(pattern, parent, sizeof(parent), leaf, leaf_size);
if (!leaf[0])
strmaxcpy(leaf, "*.*", leaf_size - 1);
if (!parent[0])
return(0);
if (!getcwd(oldcwd, oldcwd_size))
oldcwd[0] = '\0';
if (chdir(parent)) {
if (oldcwd[0])
chdir(oldcwd);
return(-1);
}
return(0);
}
static void fd_leave_parent(char *oldcwd)
{
if (oldcwd[0])
chdir(oldcwd);
}
static int fd_current_display_path(uint8 dhandle, char *out, int max)
{
char path[260];
char *p;
if (!out || max < 2)
return(-1);
out[0] = '\0';
path[0] = '\0';
if (get_dir_path(dhandle, path) || !path[0])
return(-1);
p = strchr(path, ':');
if (p)
p++;
else
p = path;
if (!*p)
out[0] = '\0';
else
strmaxcpy(out, p, max - 1);
return(0);
}
static void fd_help(void)
{
fprintf(stdout, "386 Usage: Flagdir [path [option...]]\n");
fprintf(stdout, "Options: Normal\n");
fprintf(stdout, " System\n");
fprintf(stdout, " Hidden\n");
fprintf(stdout, " Deleteinhibit\n");
fprintf(stdout, " Purge\n");
fprintf(stdout, " Renameinhibit\n");
}
static int fd_attr_mask(char *s, uint32 *setbits, uint32 *clearbits)
{
if (tool_strsame(s, "N") || tool_strsame(s, "NORMAL")) {
*clearbits |= FD_DIR_BITS;
} else if (tool_strsame(s, "S") || tool_strsame(s, "SY") ||
tool_strsame(s, "SYS") || tool_strsame(s, "SYSTEM")) {
*setbits |= FD_NWFA_SY;
} else if (tool_strsame(s, "H") || tool_strsame(s, "HIDDEN")) {
*setbits |= FD_NWFA_H;
} else if (tool_strsame(s, "DI") || tool_strsame(s, "DELETEINHIBIT")) {
*setbits |= FD_NWFA_DI;
} else if (tool_strsame(s, "P") || tool_strsame(s, "PURGE")) {
*setbits |= FD_NWFA_P;
} else if (tool_strsame(s, "RI") || tool_strsame(s, "RENAMEINHIBIT")) {
*setbits |= FD_NWFA_RI;
} else if (tool_strsame(s, "PRIVATE") || tool_strsame(s, "PR")) {
fprintf(stderr, "Private is valid on NetWare 2.15 and above, except NetWare 386.\n");
return(-1);
} else {
fprintf(stderr, "Unknown attribute: %s.\n", s);
return(-1);
}
return(0);
}
static void fd_print_attrs(uint32 attrs)
{
int any = 0;
if (!(attrs & FD_DIR_BITS)) {
fprintf(stdout, "Normal \n");
return;
}
if (attrs & FD_NWFA_SY) {
fprintf(stdout, "System");
any = 1;
}
if (attrs & FD_NWFA_H) {
fprintf(stdout, "%sHidden", any ? " " : "");
any = 1;
}
if (attrs & FD_NWFA_DI) {
fprintf(stdout, "%sDeleteInhibit", any ? " " : "");
any = 1;
}
if (attrs & FD_NWFA_P) {
fprintf(stdout, "%sPurge", any ? " " : "");
any = 1;
}
if (attrs & FD_NWFA_RI) {
fprintf(stdout, "%sRenameInhibit", any ? " " : "");
any = 1;
}
fprintf(stdout, " \n");
}
static void fd_display_header(char *path)
{
char up[260];
char prefix[260];
char header[300];
int len;
char *p;
if (tool_current_prefix(prefix, sizeof(prefix)))
prefix[0] = '\0';
tool_upcopy(up, path, sizeof(up));
/* fd_process_one() enters the parent directory before displaying the
* entry. Use the current NetWare prefix plus the leaf/relative name,
* not the original F:\... argument, otherwise the drive-qualified path is
* appended to the already changed current directory.
*/
strmaxcpy(header, prefix, sizeof(header) - 1);
if (!tool_is_current_path(up) && up[0]) {
len = strlen(header);
if (len > 0 && header[len - 1] != ':' &&
header[len - 1] != '\\' && header[len - 1] != '/') {
if (len < (int)sizeof(header) - 1) {
header[len++] = '\\';
header[len] = '\0';
}
}
if ((int)(strlen(header) + strlen(up)) < (int)sizeof(header) - 1)
strcat(header, up);
}
/* Novell FLAGDIR displays SERVER/SYS: and uses / as path separator in
* the header line.
*/
for (p = header; *p; p++) {
if (*p == '\\')
*p = '/';
}
fprintf(stdout, "%s \n", header);
}
static void fd_display_row(char *name, uint32 attrs)
{
char base[260];
tool_basename(base, name, sizeof(base));
fprintf(stdout, " %-12.12s ", base);
fd_print_attrs(attrs);
}
static void fd_display(char *path, uint32 attrs)
{
fd_display_header(path);
fd_display_row(path, attrs);
}
static int fd_is_directory(char *path)
{
struct find_t ff;
unsigned attr = _A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_SUBDIR | _A_ARCH;
if (tool_is_current_path(path))
return(1);
if (_dos_findfirst(path, attr, &ff))
return(0);
return((ff.attrib & _A_SUBDIR) != 0);
}
static int fd_obtain(char *path, uint8 dhandle, uint32 *attrs)
{
if (!fd_ncp22_1e_obtain_attrs(path, attrs))
return(0);
if (c32_ncp87_obtain_rim_attributes(path, (uint16)dhandle,
attrs, NULL, NULL, NULL) == 0)
return(0);
return(-1);
}
static int fd_modify(char *path, uint8 dhandle, uint32 attrs)
{
if (!fd_ncp22_25_modify_attrs(path, attrs))
return(0);
if (c32_ncp87_modify_dos_attributes(path, (uint16)dhandle, attrs,
NULL, NULL, NULL) == 0)
return(0);
return(-1);
}
static int fd_process_one(char *path, char *display_path, uint8 dhandle,
uint32 setbits, uint32 clearbits,
int have_change, int show_header)
{
char leaf[260];
char oldcwd[260];
char *ncp_path;
char *check_path;
uint32 attrs;
uint32 newattrs;
int rc = 0;
oldcwd[0] = '\0';
leaf[0] = '\0';
if (!tool_is_current_path(path)) {
if (fd_enter_parent(path, leaf, sizeof(leaf), oldcwd, sizeof(oldcwd))) {
fprintf(stderr, "Directory %s not found.\n", path);
return(1);
}
check_path = leaf;
ncp_path = leaf;
} else {
check_path = path;
ncp_path = "";
}
if (!fd_is_directory(check_path)) {
fd_display_header(ncp_path[0] ? ncp_path : path);
fprintf(stdout, "Directory %s not found.", ncp_path[0] ? ncp_path : path);
fd_leave_parent(oldcwd);
return(1);
}
if (fd_obtain(ncp_path, dhandle, &attrs)) {
if (tool_is_current_path(path) && display_path && !display_path[0] &&
!have_change) {
attrs = 0;
} else {
fprintf(stderr, "Unable to get directory attributes.\n");
fd_leave_parent(oldcwd);
return(1);
}
}
if (have_change) {
newattrs = (attrs | setbits) & ~clearbits;
if (newattrs != attrs) {
if (fd_modify(ncp_path, dhandle, newattrs)) {
fprintf(stderr, "Unable to change attributes.\n");
fd_leave_parent(oldcwd);
return(1);
}
attrs = newattrs;
fd_obtain(ncp_path, dhandle, &attrs);
}
}
if (show_header)
fd_display(ncp_path[0] ? ncp_path : display_path, attrs);
else
fd_display_row(ncp_path[0] ? ncp_path : display_path, attrs);
fd_leave_parent(oldcwd);
return(rc);
}
static int fd_process_wild(char *spec, uint8 dhandle,
uint32 setbits, uint32 clearbits,
int have_change)
{
struct find_t ff;
char dir[260];
char pat[260];
char search[260];
char full[260];
int found = 0;
int rc = 0;
int lines = 0;
int continuous = 0;
unsigned attr = _A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_SUBDIR | _A_ARCH;
tool_parent_pattern(dir, pat, spec, sizeof(dir), sizeof(pat));
tool_join_path(search, dir, pat, sizeof(search));
if (_dos_findfirst(search, attr, &ff) != 0) {
fprintf(stderr, "Directory %s not found.\n", spec);
return(1);
}
fd_display_header(spec);
do {
if ((ff.attrib & _A_SUBDIR) && strcmp(ff.name, ".") &&
strcmp(ff.name, "..")) {
tool_join_path(full, dir, ff.name, sizeof(full));
if (fd_process_one(full, ff.name, dhandle, setbits, clearbits,
have_change, 0))
rc = 1;
found++;
tool_page_line(&lines, &continuous);
}
} while (_dos_findnext(&ff) == 0);
if (!found) {
fprintf(stderr, "Directory %s not found.\n", spec);
return(1);
}
return(rc);
}
int func_flagdir(int argc, char *argv[], int mode)
{
char *path = ".";
char display_path[260];
uint8 connid = 0;
uint8 dhandle = 0;
uint32 setbits = 0;
uint32 clearbits = 0;
int have_change = 0;
int i;
(void)mode;
if (argc > 1 && (tool_strsame(argv[1], "/?") || tool_strsame(argv[1], "-?") ||
tool_strsame(argv[1], "?"))) {
fd_help();
return(0);
}
if (argc > 1)
path = argv[1];
if (tool_current_dhandle(&connid, &dhandle)) {
fprintf(stderr, "FlagDir only works on network directories.\n");
return(1);
}
for (i = 2; i < argc; i++) {
if (fd_attr_mask(argv[i], &setbits, &clearbits))
return(1);
have_change = 1;
}
if (tool_has_wildcards(path))
return(fd_process_wild(path, dhandle, setbits, clearbits, have_change));
if (tool_is_current_path(path)) {
if (fd_current_display_path(dhandle, display_path, sizeof(display_path)))
strcpy(display_path, ".");
} else {
strmaxcpy(display_path, path, sizeof(display_path) - 1);
}
return(fd_process_one(path, display_path, dhandle,
setbits, clearbits, have_change, 1));
}
Reference in New Issue View Git Blame Copy Permalink