repos/Syncify/Syncify.cpp

// Syncify
//
// Douglas Thrift
//
// $Id$

#include "Syncify.hpp"

#include <menes-api/exename.hpp>
#include <menes-app/simple.hpp>

#include <stdio.h>

int Main(const app::Options& options)
{
        ext::String local("."), remote, pattern("^.*$");
        
        _foreach (const app::ArgumentList, arg, app::GetArguments())
        {
                Matcher matcher;

                if (*arg == matcher("^-local=(.+)$"))
                        local = matcher[1];
                else if (*arg == matcher("^-remote=(.+)$"))
                        remote = matcher[1];
                else if (*arg == matcher("^-pattern=(.+)$"))
                        pattern = matcher[1];
                else if (*arg == "-D")
                        Syncify::debug = true;
                else
                {
                        api::Cerr << "Usage: " << Syncify::program << " [-local=local] -remote=remote [-pattern=pattern] [-D]" << ios::NewLine;

                        return 1;
                }
        }

        if (remote.IsEmpty())
        {
                api::Cerr << "Usage: " << Syncify::program << " [-local=local] -remote=remote [-pattern=pattern] [-D]" << ios::NewLine;

                return 1;
        }

        Syncify syncify(local, remote, pattern);
        
        return 0;
}

extern "C"
{
        void authenticate(const char* srv, const char* shr, char* wg, int wglen, char* un, int unlen, char* pw, int pwlen)
        {
                static ext::Buffer user("Douglas Thrift"), password(::getpass("Password:"));

                _foreach (ext::Buffer, atom, user)
                        un[_index] = *atom;
                _foreach (ext::Buffer, atom, password)
                        pw[_index] = *atom;

                un[user.GetSize() < size_t(unlen) ? user.GetSize() : unlen - 1] = '\0';
                pw[password.GetSize() < size_t(pwlen) ? password.GetSize() : pwlen - 1] = '\0';
        }
}

Syncify::Syncify(const ext::String& local, const ext::String& remote, const ext::String& pattern) : pattern(pattern)
{
        CheckError(::smbc_init(authenticate, debug ? 2 : 0));

        syncify(local, remote);
}

Syncify::~Syncify()
{
        ::smbc_free_context(::smbc_set_context(NULL), 1);
}

ext::String Syncify::program(api::GetExecutablePath().GetName());
bool Syncify::debug(false);

void Syncify::syncify(const ext::String& local, const ext::String& remote)
{
        try
        {
                Matcher dots("^\\.{1,2}$");
                ext::RedBlackSet<ext::String> directories;
                int directory(CheckError(::smbc_opendir(remote.NullTerminate())));

                for (::smbc_dirent* entity(::smbc_readdir(directory)); entity != NULL; entity = ::smbc_readdir(directory)) switch (entity->smbc_type)
                {
                case SMBC_FILE:
                        if (entity->name == pattern)
                        {
                                api::Cout << entity->name << ios::NewLine;
                        }
                        break;
                case SMBC_DIR:
                case SMBC_LINK:
                        if (entity->name != dots)
                                directories.Insert(entity->name);
                }

                ::smbc_closedir(directory);

                _foreach (const ext::RedBlackSet<ext::String>, directory, directories)
                        syncify(local + "/" + *directory, remote + "/" + *directory);
        }
        catch (const Error& error)
        {
                api::Cerr << error.GetMessage() << remote << ios::NewLine;
        }
}
Revision:	438
Committed:	2005-04-05T16:14:43-07:00 (20 years, 2 months ago) by douglas
File size:	2702 byte(s)
Log Message:	More correct, probably.
#	User	Rev	Content
1	douglas	435	// Syncify
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7			#include "Syncify.hpp"
8
9			#include <menes-api/exename.hpp>
10			#include <menes-app/simple.hpp>
11
12	douglas	436	#include <stdio.h>
13
14	douglas	435	int Main(const app::Options& options)
15			{
16	douglas	436	ext::String local("."), remote, pattern("^.*$");
17	douglas	435
18			_foreach (const app::ArgumentList, arg, app::GetArguments())
19			{
20	douglas	436	Matcher matcher;
21
22			if (*arg == matcher("^-local=(.+)$"))
23			local = matcher[1];
24			else if (*arg == matcher("^-remote=(.+)$"))
25			remote = matcher[1];
26			else if (*arg == matcher("^-pattern=(.+)$"))
27			pattern = matcher[1];
28			else if (*arg == "-D")
29	douglas	435	Syncify::debug = true;
30			else
31			{
32	douglas	436	api::Cerr << "Usage: " << Syncify::program << " [-local=local] -remote=remote [-pattern=pattern] [-D]" << ios::NewLine;
33	douglas	435
34			return 1;
35			}
36			}
37
38	douglas	436	if (remote.IsEmpty())
39			{
40			api::Cerr << "Usage: " << Syncify::program << " [-local=local] -remote=remote [-pattern=pattern] [-D]" << ios::NewLine;
41
42			return 1;
43			}
44
45			Syncify syncify(local, remote, pattern);
46	douglas	435
47			return 0;
48			}
49
50			extern "C"
51			{
52	douglas	436	void authenticate(const char* srv, const char* shr, char* wg, int wglen, char* un, int unlen, char* pw, int pwlen)
53			{
54	douglas	438	static ext::Buffer user("Douglas Thrift"), password(::getpass("Password:"));
55	douglas	436
56	douglas	438	_foreach (ext::Buffer, atom, user)
57	douglas	437	un[_index] = *atom;
58	douglas	438	_foreach (ext::Buffer, atom, password)
59	douglas	437	pw[_index] = *atom;
60
61			un[user.GetSize() < size_t(unlen) ? user.GetSize() : unlen - 1] = '\0';
62			pw[password.GetSize() < size_t(pwlen) ? password.GetSize() : pwlen - 1] = '\0';
63	douglas	436	}
64	douglas	435	}
65
66	douglas	436	Syncify::Syncify(const ext::String& local, const ext::String& remote, const ext::String& pattern) : pattern(pattern)
67			{
68			CheckError(::smbc_init(authenticate, debug ? 2 : 0));
69
70			syncify(local, remote);
71			}
72
73			Syncify::~Syncify()
74			{
75			::smbc_free_context(::smbc_set_context(NULL), 1);
76			}
77
78	douglas	435	ext::String Syncify::program(api::GetExecutablePath().GetName());
79			bool Syncify::debug(false);
80	douglas	436
81			void Syncify::syncify(const ext::String& local, const ext::String& remote)
82			{
83	douglas	437	try
84			{
85			Matcher dots("^\\.{1,2}$");
86			ext::RedBlackSet<ext::String> directories;
87			int directory(CheckError(::smbc_opendir(remote.NullTerminate())));
88	douglas	436
89	douglas	437	for (::smbc_dirent* entity(::smbc_readdir(directory)); entity != NULL; entity = ::smbc_readdir(directory)) switch (entity->smbc_type)
90	douglas	436	{
91	douglas	437	case SMBC_FILE:
92			if (entity->name == pattern)
93			{
94			api::Cout << entity->name << ios::NewLine;
95			}
96			break;
97			case SMBC_DIR:
98			case SMBC_LINK:
99			if (entity->name != dots)
100			directories.Insert(entity->name);
101	douglas	436	}
102
103	douglas	437	::smbc_closedir(directory);
104	douglas	436
105	douglas	437	_foreach (const ext::RedBlackSet<ext::String>, directory, directories)
106			syncify(local + "/" + directory, remote + "/" + directory);
107			}
108			catch (const Error& error)
109			{
110			api::Cerr << error.GetMessage() << remote << ios::NewLine;
111			}
112	douglas	436	}