static rc_t init_ictx( struct ictx * ictx, const dump_context * ctx, const Args * args )
{
rc_t rc = KFileMakeStdIn ( &( ictx->std_in ) );
DISP_RC( rc, "KFileMakeStdIn() failed" );
if ( rc == 0 )
{
ictx->ctx = ctx;
ictx->args = args;
VectorInit( &ictx->history, 0, 10 );
ictx->interactive = ( KFileType ( ictx->std_in ) == kfdCharDev );
ictx->done = false;
CONST_STRING( &(ictx->PROMPT), "\nvdb $" );
StringInit( &(ictx->SInputLine), &( ictx->inputline[0] ), sizeof( ictx->inputline ), 0 );
rc = vdp_init_ctx( &ictx->vsctx, args );
}
return rc;
}
static
rc_t privReadStdinLine(char* buf, size_t bsize, bool destroy)
{
rc_t rc = 0;
static const KFile* std_in = NULL;
static uint64_t pos = 0;
size_t num_read = 0;
if (destroy) {
RELEASE(KFile, std_in);
pos = 0;
return rc;
}
if (std_in == NULL) {
rc = KFileMakeStdIn(&std_in);
if (rc != 0) {
DISP_RC(rc, "KFileMakeStdIn");
return rc;
}
}
rc = KFileRead(std_in, pos, buf, bsize, &num_read);
DISP_RC(rc, "KFileRead");
pos += num_read;
if (num_read) {
bool done = false;
buf[num_read] = '\0';
while (num_read > 0 && !done) {
switch (buf[num_read - 1]) {
case '\n':
case '\r':
buf[--num_read] = '\0';
break;
default:
done = true;
break;
}
}
}
return rc;
}
static
rc_t FileToFile (const KDirectory * sd, const char * source,
KDirectory *dd, const char * dest_, bool try_rename,
char * base)
{
const KFile * infile;
rc_t rc;
uint32_t access;
KTime_t date;
bool is_tmp;
char dest [MY_MAX_PATH + sizeof EncExt];
strcpy (dest, dest_);
if (try_rename)
NameFixUp (dest);
if ((sd == dd) && (strcmp (source, dest) == 0))
return FileInPlace (dd, dest, try_rename);
if (base == NULL)
STSMSG (1, ("%scrypting file %s to %s", De, source, dest));
else
STSMSG (1, ("%scrypting file %s to %s/%s", De, source, base, dest));
/*
* A Hack to make stdin/stout work within KFS
*/
if (UseStdin)
{
const KFile * iinfile;
rc = KFileMakeStdIn (&iinfile);
if (rc == 0)
{
rc = KBufReadFileMakeRead (&infile, iinfile, 64 * 1024);
KFileRelease (iinfile);
if (rc == 0)
{
access = 0640;
date = 0;
goto stdin_shortcut;
}
LOGERR (klogErr, rc, "error wrapping stdin");
return rc;
}
}
rc = 0;
is_tmp = IsTmpFile (source);
if (is_tmp)
{
TmpFoundFlag = true;
if (ForceFlag)
; /* LOG OVERWRITE */
else
; /* LOG TMP */
}
if (!is_tmp || ForceFlag)
{
rc = KDirectoryAccess (sd, &access, "%s", source);
if (rc)
LOGERR (klogErr, rc, "Error check permission of source");
else
{
rc = KDirectoryDate (sd, &date, "%s", source);
if (rc)
LOGERR (klogErr, rc, "Error check date of source");
else
{
rc = KDirectoryOpenFileRead (sd, &infile, "%s", source);
if (rc)
PLOGERR (klogErr, (klogErr, rc,
"Error opening source file '$(S)'",
"S=%s", source));
else
{
EncScheme scheme;
stdin_shortcut:
rc = EncryptionTypeCheck (infile, source, &scheme);
if (rc == 0)
{
KFile * outfile;
uint32_t kcm;
/*
* Hack to support stdout before VFS is complete enough to use here
*/
if (UseStdout)
{
rc = KFileMakeStdOut (&outfile);
if (rc)
LOGERR (klogErr, rc, "error wrapping stdout");
}
else
{
kcm = ForceFlag ? kcmInit|kcmParents : kcmCreate|kcmParents;
rc = KDirectoryCreateFile (dd, &outfile, false, 0600, kcm, "%s", dest);
if (rc)
PLOGERR (klogErr,(klogErr, rc, "error opening output '$(O)'",
"O=%s", dest));
}
if (rc == 0)
{
const KFile * Infile;
KFile * Outfile;
rc = CryptFile (infile, &Infile, outfile, &Outfile, scheme);
if (rc == 0)
{
rc = CopyFile (Infile, Outfile, source, dest);
if (rc == 0)
{
if (UseStdin || UseStdout)
;
else
{
rc = KDirectorySetAccess (dd, false, access, 0777,
"%s", dest);
if (rc == 0 && date != 0)
rc = KDirectorySetDate (dd, false, date, "%s", dest);
}
}
KFileRelease (Infile);
KFileRelease (Outfile);
}
KFileRelease (outfile);
}
}
KFileRelease (infile);
}
}
}
}
return rc;
}
static
rc_t
WorkerThreadFn ( const KThread *self, void *data )
{
KStream* stream = (KStream*)data;
char buf[256];
size_t num;
rc_t rc = KStreamReadAll(stream, buf, 1, &num);
if (rc == 0)
{
if (num == 1)
{
size_t toRead = (unsigned char)buf[0];
pLogMsg(klogInfo, "KeyringServer: worker received length=$(l)\n", "l=%d", toRead);
rc = KStreamReadAll(stream, buf, toRead, &num);
if (rc == 0)
{
/*pLogMsg(klogInfo, "KeyringServer: worker received msg='$(buf)'\n", "buf=%.*s", num, buf);*/
switch (buf[0])
{
case 'I':
if (buf[0] == 'I') /* init */
{
LogMsg ( klogInfo, "KeyringServer: received Init");
if (keyring == 0)
{
const KFile* std_in;
rc = KFileMakeStdIn ( &std_in );
if (rc == 0)
{
KFile* std_out;
rc = KFileMakeStdOut ( &std_out );
if (rc == 0)
{
rc = KeyRingOpen(&keyring, keyRingFileName, std_in, std_out);
if (rc == 0)
{
LogMsg ( klogInfo, "KeyringServer: Init successful");
pLogMsg(klogInfo, "KeyringServer: sending '$(buf)'\n", "buf=%.*s", string_size(initMsgSuccess), initMsgSuccess);
rc = KStreamWrite(stream, initMsgSuccess, string_size(initMsgSuccess), NULL);
}
else
{
rc_t rc2;
LogErr(klogErr, rc, "KeyringServer: Init failed");
rc2 = KStreamWrite(stream, initMsgFailure, string_size(initMsgFailure), NULL);
if (rc == 0)
rc = rc2;
}
KFileRelease(std_out);
}
KFileRelease(std_in);
}
}
else
{ /* already running */
LogMsg ( klogInfo, "KeyringServer: Init successful");
rc = KStreamWrite(stream, initMsgSuccess, string_size(initMsgSuccess), NULL);
}
}
break;
case 'X':
if (buf[0] == 'X') /* shutDown */
{
LogMsg ( klogInfo, "KeyringServer: received Shutdown");
shutDown = true;
}
break;
case 'P': /* project */
if (toRead > 1 && buf[1] == 'A') /* Add */
{
String pkey;
String dlkey;
String enckey;
size_t idx = 2;
/*TODO: make sure idx is in range*/
StringInit(&pkey, buf + idx + 1, buf[idx], buf[idx]);
pkey.len = string_len(pkey.addr, pkey.size);
idx += pkey.size + 1;
/*TODO: make sure idx is in range*/
StringInit(&dlkey, buf + idx + 1, buf[idx], buf[idx]);
dlkey.len = string_len(dlkey.addr, dlkey.size);
idx += dlkey.size + 1;
/*TODO: make sure idx is in range*/
StringInit(&enckey, buf + idx + 1, buf[idx], buf[idx]);
enckey.len = string_len(enckey.addr, enckey.size);
pLogMsg(klogInfo,
"KeyringServer: received Project Add(pkey='$(pkey)',dlkey='$(dlkey)',enckey='$(.....)')'\n",
"pkey=%.*s,dlkey=%.*s,enckey=%.*s",
pkey.len, pkey.addr, dlkey.len, dlkey.addr, enckey.len, enckey.addr);
rc = KeyRingAddProject(keyring, &pkey, &dlkey, &enckey);
if (rc != 0)
LogErr(klogErr, rc, "KeyringServer: KeyRingAddProject() failed");
}
break;
default:
LogMsg ( klogInfo, "KeyringServer: unrecognised message received");
break;
}
}
else
LogErr(klogErr, rc, "KeyringServer: KStreamRead(body) failed");
}
else /* end of stream = the client closed the connection */
LogMsg(klogInfo, "KeyringServer: worker received EOF\n");
}
else
LogErr(klogErr, rc, "KeyringServer: KStreamRead(length) failed");
LogMsg ( klogInfo, "KeyringServer: worker done");
return KThreadRelease(self);
}
static
rc_t run ()
{
const KFile * in;
rc_t rc = 0;
do {
uint64_t in_pos = 0;
size_t num_read;
char buffer [8 * 1024];
rc = KFileMakeStdIn (&in);
if (rc) break;
for ( ;; )
{
VPath * path;
rc = KOutMsg ("Enter a system specific path: ");
if (rc) break;
memset (buffer, 0, sizeof buffer);
rc = KFileRead (in, in_pos, buffer, sizeof buffer, &num_read);
if (rc)
{
LOGERR (klogFatal, rc, "error with KFileRead");
break;
}
if (num_read == 0) break;
in_pos += num_read;
if (buffer[num_read-1] == '\n')
buffer[num_read-1] = '\0';
if (buffer[num_read-2] == '\r')
buffer[num_read-2] = '\0';
rc = VPathMakeSysPath (&path, buffer);
if (rc)
{
LOGERR (klogErr, rc, "error with MakeSysPath");
break;
}
memset (buffer, 0, sizeof buffer);
rc = VPathReadPath (path, buffer, sizeof buffer, &num_read);
if (rc)
{
LOGERR (klogErr, rc, "error wth ReadPath");
break;
}
rc = KOutMsg ("VPath path is '%s' size '%zu'\n\n", buffer, num_read);
if (rc)
{
LOGERR (klogErr, rc, "error with KOuMsg");
break;
}
}
} while (0);
return rc;
}
