void* st_malloc(size_t s){
void *temp;
if(st_mem == NULL) sk_init(&st_mem);
temp = malloc(s);
if(sk_push(&st_mem, temp) == 0) fatal(STR_OUT_OF_MEMORY);
return temp;
}
struct config_tag * wcplg_open_sftp_session(char *userhost, char *user, char *pass, int portnumber) {
wcplg_set_last_error_msg(NULL);
connectMsg = userhost;
if (ProgressProc("connecting", connectMsg, 0) == 1) {
wcplg_set_last_error_msg("cancel by user");
return RESULT_ERR;
}
if (!user && !pass && !portnumber) {
if (!cfg.host[0])
do_defaults(userhost, &cfg);
userhost = cfg.host;
user = cfg.username;
portnumber = cfg.port;
loaded_session = 1;
} else {
console_password = dupstr(pass);
flags = 0; //FLAG_STDERR | FLAG_INTERACTIVE;
cmdline_tooltype = TOOLTYPE_FILETRANSFER;
//ssh_get_line = &console_get_line;
do_defaults(NULL, &cfg);
}
// init_winsock();
sk_init();
back = NULL;
if (userhost) {
if (psftp_connect(userhost, user, portnumber)) {
return RESULT_ERR;
}
if (1 == ProgressProc("connecting", connectMsg, 99))
return RESULT_ERR;
if (do_sftp_init()) {
return RESULT_ERR;
}
} else {
printf("psftp: no hostname specified; use \"open host.name\" to connect\n");
return RESULT_ERR;
}
ISinitT = 1;
disconnected = 0;
cfg.sftp4tc.selectedSession = selectedSession;
return &cfg;
}
int main(int argc, char **argv)
{
extern int pt_main(int argc, char **argv);
sk_init();
flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
default_protocol = be_default_protocol;
/* Find the appropriate default port. */
{
Backend *b = backend_from_proto(default_protocol);
default_port = 0; /* illegal */
if (b)
default_port = b->default_port;
}
return pt_main(argc, argv);
}
int main(int argc, char **argv)
{
extern int pt_main(int argc, char **argv);
int ret;
sk_init();
flags = FLAG_VERBOSE | FLAG_INTERACTIVE;
default_protocol = be_default_protocol;
/* Find the appropriate default port. */
{
Backend *b = backend_from_proto(default_protocol);
default_port = 0; /* illegal */
if (b)
default_port = b->default_port;
}
ret = pt_main(argc, argv);
cleanup_exit(ret);
return ret; /* not reached, but placates optimisers */
}
void PuttyInitialize()
{
SaveRandomSeed = true;
// make sure random generator is initialised, so random_save_seed()
// in destructor can proceed
random_ref();
flags = FLAG_VERBOSE/* | FLAG_SYNCAGENT*/; // verbose log
sk_init();
AnsiString VersionString = AnsiString(GetSshVersionString());
DebugAssert(!VersionString.IsEmpty() && (static_cast<size_t>(VersionString.Length()) < _countof(sshver)));
strncpy(sshver, VersionString.c_str(), sizeof(sshver));
AnsiString AppName = AnsiString(GetAppNameString());
DebugAssert(!AppName.IsEmpty() && (static_cast<size_t>(AppName.Length()) < _countof(appname_)));
strncpy(appname_, AppName.c_str(), sizeof(appname_));
}
//---------------------------------------------------------------------------
void __fastcall PuttyInitialize()
{
SaveRandomSeed = true;
InitializeCriticalSection(&putty_section);
// make sure random generator is initialised, so random_save_seed()
// in destructor can proceed
random_ref();
flags = FLAG_VERBOSE | FLAG_SYNCAGENT; // verbose log
sk_init();
AnsiString VersionString = SshVersionString();
assert(!VersionString.IsEmpty() && (static_cast<size_t>(VersionString.Length()) < LENOF(sshver)));
strcpy(sshver, VersionString.c_str());
AnsiString AppName = AppNameString();
assert(!AppName.IsEmpty() && (static_cast<size_t>(AppName.Length()) < LENOF(appname_)));
strcpy(appname_, AppName.c_str());
}
int wcplg_open_sftp_session(char *userhost, char *user, char *pass,
int portnumber)
{
wcplg_set_last_error_msg(NULL);
if (ProgressProc("", "", 0) == 1) {
wcplg_set_last_error_msg("cancel by user");
return RESULT_ERR;
}
console_password = dupstr(pass);
flags = 0; //FLAG_STDERR | FLAG_INTERACTIVE;
cmdline_tooltype = TOOLTYPE_FILETRANSFER;
ssh_get_line = &console_get_line;
do_defaults(NULL, &cfg);
init_winsock();
sk_init();
back = NULL;
if (userhost) {
if (psftp_connect(userhost, user, portnumber)) {
return RESULT_ERR;
}
if (do_sftp_init()) {
return RESULT_ERR;
}
} else {
printf
("psftp: no hostname specified; use \"open host.name\" to connect\n");
return RESULT_ERR;
}
ISinitT = 1;
return RESULT_OK;
}
int main(int argc, char ** argv)
{
event_loop * evl;
io_pipe * io_c2p;
io_pipe * io_p2s;
io_bridge * br;
sockaddr_in sa;
char buf[128];
int sk, c2p, p2s;
int yes = 1;
//
// signal(SIGPIPE, SIG_IGN);
//
evl = new_event_loop_select();
//
if (sk_init() < 0)
return 1;
sk = sk_create(AF_INET, SOCK_STREAM, 0);
if (sk < 0)
return 2;
sockaddr_in_init(&sa);
SOCKADDR_IN_PORT(&sa) = htons(55555);
if (sk_setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes) < 0 ||
sk_bind_ip4(sk, &sa) < 0 ||
sk_listen(sk, 8) < 0)
return 3;
printf("listening on %s ...\n", sa_to_str(&sa, buf, sizeof buf));
//
c2p = sk_accept_ip4(sk, &sa);
if (c2p < 0)
return 4;
printf("accepted\n");
sk_unblock(c2p);
//
SOCKADDR_IN_ADDR(&sa) = inet_addr(argc > 1 ? argv[1] : "127.0.0.1");
SOCKADDR_IN_PORT(&sa) = htons( (argc > 2) ? atoi(argv[2]) : 22 );
p2s = sk_create(AF_INET, SOCK_STREAM, 0);
if (p2s < 0)
return 5;
if (sk_unblock(p2s) < 0)
return 6;
printf("connecting to %s ...\n", sa_to_str(&sa, buf, sizeof buf));
if (sk_connect_ip4(p2s, &sa) < 0 &&
sk_conn_fatal(sk_errno(p2s)))
return 7;
//
io_c2p = new_tcp_pipe(c2p);
io_p2s = new_tcp_pipe(p2s);
br = new_io_bridge(io_c2p, io_p2s);
br->on_shutdown = on_bridge_down;
br->init(br, evl);
while (! enough)
{
static uint tick = 0;
evl->monitor(evl, 100);
if ( (tick++ % 17) && ! enough )
continue;
printf("\r%u | [%c%c %10llu %10llu %4u] [%c%c %10llu %10llu %4u]",
tick++,
br->l->pipe->writable ? 'w' :
br->l->pipe->fin_sent ? 'x' : '-',
br->l->pipe->readable ? 'r' :
br->l->pipe->fin_rcvd ? 'x' : '-',
br->l->tx, br->l->rx, br->l->congestions,
br->r->pipe->writable ? 'w' :
br->r->pipe->fin_sent ? 'x' : '-',
br->r->pipe->readable ? 'r' :
br->r->pipe->fin_rcvd ? 'x' : '-',
br->r->tx, br->r->rx, br->r->congestions);
fflush(stdout);
}
printf("\n");
return 0;
}
int main(int argc, char **argv)
{
bool sending;
SOCKET *sklist;
size_t skcount, sksize;
int exitcode;
bool errors;
bool use_subsystem = false;
bool just_test_share_exists = false;
enum TriState sanitise_stdout = AUTO, sanitise_stderr = AUTO;
unsigned long now, next, then;
const struct BackendVtable *vt;
dll_hijacking_protection();
sklist = NULL;
skcount = sksize = 0;
/*
* Initialise port and protocol to sensible defaults. (These
* will be overridden by more or less anything.)
*/
default_protocol = PROT_SSH;
default_port = 22;
flags = 0;
cmdline_tooltype |=
(TOOLTYPE_HOST_ARG |
TOOLTYPE_HOST_ARG_CAN_BE_SESSION |
TOOLTYPE_HOST_ARG_PROTOCOL_PREFIX |
TOOLTYPE_HOST_ARG_FROM_LAUNCHABLE_LOAD);
/*
* Process the command line.
*/
conf = conf_new();
do_defaults(NULL, conf);
loaded_session = false;
default_protocol = conf_get_int(conf, CONF_protocol);
default_port = conf_get_int(conf, CONF_port);
errors = false;
{
/*
* Override the default protocol if PLINK_PROTOCOL is set.
*/
char *p = getenv("PLINK_PROTOCOL");
if (p) {
const struct BackendVtable *vt = backend_vt_from_name(p);
if (vt) {
default_protocol = vt->protocol;
default_port = vt->default_port;
conf_set_int(conf, CONF_protocol, default_protocol);
conf_set_int(conf, CONF_port, default_port);
}
}
}
while (--argc) {
char *p = *++argv;
int ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),
1, conf);
if (ret == -2) {
fprintf(stderr,
"plink: option \"%s\" requires an argument\n", p);
errors = true;
} else if (ret == 2) {
--argc, ++argv;
} else if (ret == 1) {
continue;
} else if (!strcmp(p, "-batch")) {
console_batch_mode = true;
} else if (!strcmp(p, "-s")) {
/* Save status to write to conf later. */
use_subsystem = true;
} else if (!strcmp(p, "-V") || !strcmp(p, "--version")) {
version();
} else if (!strcmp(p, "--help")) {
usage();
} else if (!strcmp(p, "-pgpfp")) {
pgp_fingerprints();
exit(1);
} else if (!strcmp(p, "-shareexists")) {
just_test_share_exists = true;
} else if (!strcmp(p, "-sanitise-stdout") ||
!strcmp(p, "-sanitize-stdout")) {
sanitise_stdout = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stdout") ||
!strcmp(p, "-no-sanitize-stdout")) {
sanitise_stdout = FORCE_OFF;
} else if (!strcmp(p, "-sanitise-stderr") ||
!strcmp(p, "-sanitize-stderr")) {
sanitise_stderr = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stderr") ||
!strcmp(p, "-no-sanitize-stderr")) {
sanitise_stderr = FORCE_OFF;
} else if (!strcmp(p, "-no-antispoof")) {
console_antispoof_prompt = false;
} else if (*p != '-') {
strbuf *cmdbuf = strbuf_new();
while (argc > 0) {
if (cmdbuf->len > 0)
put_byte(cmdbuf, ' '); /* add space separator */
put_datapl(cmdbuf, ptrlen_from_asciz(p));
if (--argc > 0)
p = *++argv;
}
conf_set_str(conf, CONF_remote_cmd, cmdbuf->s);
conf_set_str(conf, CONF_remote_cmd2, "");
conf_set_bool(conf, CONF_nopty, true); /* command => no tty */
strbuf_free(cmdbuf);
break; /* done with cmdline */
} else {
fprintf(stderr, "plink: unknown option \"%s\"\n", p);
errors = true;
}
}
if (errors)
return 1;
if (!cmdline_host_ok(conf)) {
usage();
}
prepare_session(conf);
/*
* Perform command-line overrides on session configuration.
*/
cmdline_run_saved(conf);
/*
* Apply subsystem status.
*/
if (use_subsystem)
conf_set_bool(conf, CONF_ssh_subsys, true);
if (!*conf_get_str(conf, CONF_remote_cmd) &&
!*conf_get_str(conf, CONF_remote_cmd2) &&
!*conf_get_str(conf, CONF_ssh_nc_host))
flags |= FLAG_INTERACTIVE;
/*
* Select protocol. This is farmed out into a table in a
* separate file to enable an ssh-free variant.
*/
vt = backend_vt_from_proto(conf_get_int(conf, CONF_protocol));
if (vt == NULL) {
fprintf(stderr,
"Internal fault: Unsupported protocol found\n");
return 1;
}
sk_init();
if (p_WSAEventSelect == NULL) {
fprintf(stderr, "Plink requires WinSock 2\n");
return 1;
}
/*
* Plink doesn't provide any way to add forwardings after the
* connection is set up, so if there are none now, we can safely set
* the "simple" flag.
*/
if (conf_get_int(conf, CONF_protocol) == PROT_SSH &&
!conf_get_bool(conf, CONF_x11_forward) &&
!conf_get_bool(conf, CONF_agentfwd) &&
!conf_get_str_nthstrkey(conf, CONF_portfwd, 0))
conf_set_bool(conf, CONF_ssh_simple, true);
logctx = log_init(default_logpolicy, conf);
if (just_test_share_exists) {
if (!vt->test_for_upstream) {
fprintf(stderr, "Connection sharing not supported for connection "
"type '%s'\n", vt->name);
return 1;
}
if (vt->test_for_upstream(conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port), conf))
return 0;
else
return 1;
}
if (restricted_acl) {
lp_eventlog(default_logpolicy, "Running with restricted process ACL");
}
/*
* Start up the connection.
*/
netevent = CreateEvent(NULL, false, false, NULL);
{
const char *error;
char *realhost;
/* nodelay is only useful if stdin is a character device (console) */
bool nodelay = conf_get_bool(conf, CONF_tcp_nodelay) &&
(GetFileType(GetStdHandle(STD_INPUT_HANDLE)) == FILE_TYPE_CHAR);
error = backend_init(vt, plink_seat, &backend, logctx, conf,
conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port),
&realhost, nodelay,
conf_get_bool(conf, CONF_tcp_keepalives));
if (error) {
fprintf(stderr, "Unable to open connection:\n%s", error);
return 1;
}
sfree(realhost);
}
inhandle = GetStdHandle(STD_INPUT_HANDLE);
outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
errhandle = GetStdHandle(STD_ERROR_HANDLE);
/*
* Turn off ECHO and LINE input modes. We don't care if this
* call fails, because we know we aren't necessarily running in
* a console.
*/
GetConsoleMode(inhandle, &orig_console_mode);
SetConsoleMode(inhandle, ENABLE_PROCESSED_INPUT);
/*
* Pass the output handles to the handle-handling subsystem.
* (The input one we leave until we're through the
* authentication process.)
*/
stdout_handle = handle_output_new(outhandle, stdouterr_sent, NULL, 0);
stderr_handle = handle_output_new(errhandle, stdouterr_sent, NULL, 0);
handle_sink_init(&stdout_hs, stdout_handle);
handle_sink_init(&stderr_hs, stderr_handle);
stdout_bs = BinarySink_UPCAST(&stdout_hs);
stderr_bs = BinarySink_UPCAST(&stderr_hs);
/*
* Decide whether to sanitise control sequences out of standard
* output and standard error.
*
* If we weren't given a command-line override, we do this if (a)
* the fd in question is pointing at a console, and (b) we aren't
* trying to allocate a terminal as part of the session.
*
* (Rationale: the risk of control sequences is that they cause
* confusion when sent to a local console, so if there isn't one,
* no problem. Also, if we allocate a remote terminal, then we
* sent a terminal type, i.e. we told it what kind of escape
* sequences we _like_, i.e. we were expecting to receive some.)
*/
if (sanitise_stdout == FORCE_ON ||
(sanitise_stdout == AUTO && is_console_handle(outhandle) &&
conf_get_bool(conf, CONF_nopty))) {
stdout_scc = stripctrl_new(stdout_bs, true, L'\0');
stdout_bs = BinarySink_UPCAST(stdout_scc);
}
if (sanitise_stderr == FORCE_ON ||
(sanitise_stderr == AUTO && is_console_handle(errhandle) &&
conf_get_bool(conf, CONF_nopty))) {
stderr_scc = stripctrl_new(stderr_bs, true, L'\0');
stderr_bs = BinarySink_UPCAST(stderr_scc);
}
main_thread_id = GetCurrentThreadId();
sending = false;
now = GETTICKCOUNT();
while (1) {
int nhandles;
HANDLE *handles;
int n;
DWORD ticks;
if (!sending && backend_sendok(backend)) {
stdin_handle = handle_input_new(inhandle, stdin_gotdata, NULL,
0);
sending = true;
}
if (toplevel_callback_pending()) {
ticks = 0;
next = now;
} else if (run_timers(now, &next)) {
then = now;
now = GETTICKCOUNT();
if (now - then > next - then)
ticks = 0;
else
ticks = next - now;
} else {
ticks = INFINITE;
/* no need to initialise next here because we can never
* get WAIT_TIMEOUT */
}
handles = handle_get_events(&nhandles);
handles = sresize(handles, nhandles+1, HANDLE);
handles[nhandles] = netevent;
n = MsgWaitForMultipleObjects(nhandles+1, handles, false, ticks,
QS_POSTMESSAGE);
if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)nhandles) {
handle_got_event(handles[n - WAIT_OBJECT_0]);
} else if (n == WAIT_OBJECT_0 + nhandles) {
WSANETWORKEVENTS things;
SOCKET socket;
int i, socketstate;
/*
* We must not call select_result() for any socket
* until we have finished enumerating within the tree.
* This is because select_result() may close the socket
* and modify the tree.
*/
/* Count the active sockets. */
i = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) i++;
/* Expand the buffer if necessary. */
sgrowarray(sklist, sksize, i);
/* Retrieve the sockets into sklist. */
skcount = 0;
for (socket = first_socket(&socketstate);
socket != INVALID_SOCKET;
socket = next_socket(&socketstate)) {
sklist[skcount++] = socket;
}
/* Now we're done enumerating; go through the list. */
for (i = 0; i < skcount; i++) {
WPARAM wp;
socket = sklist[i];
wp = (WPARAM) socket;
if (!p_WSAEnumNetworkEvents(socket, NULL, &things)) {
static const struct { int bit, mask; } eventtypes[] = {
{FD_CONNECT_BIT, FD_CONNECT},
{FD_READ_BIT, FD_READ},
{FD_CLOSE_BIT, FD_CLOSE},
{FD_OOB_BIT, FD_OOB},
{FD_WRITE_BIT, FD_WRITE},
{FD_ACCEPT_BIT, FD_ACCEPT},
};
int e;
noise_ultralight(NOISE_SOURCE_IOID, socket);
for (e = 0; e < lenof(eventtypes); e++)
if (things.lNetworkEvents & eventtypes[e].mask) {
LPARAM lp;
int err = things.iErrorCode[eventtypes[e].bit];
lp = WSAMAKESELECTREPLY(eventtypes[e].mask, err);
select_result(wp, lp);
}
}
}
} else if (n == WAIT_OBJECT_0 + nhandles + 1) {
MSG msg;
while (PeekMessage(&msg, INVALID_HANDLE_VALUE,
WM_AGENT_CALLBACK, WM_AGENT_CALLBACK,
PM_REMOVE)) {
struct agent_callback *c = (struct agent_callback *)msg.lParam;
c->callback(c->callback_ctx, c->data, c->len);
sfree(c);
}
}
run_toplevel_callbacks();
if (n == WAIT_TIMEOUT) {
now = next;
} else {
now = GETTICKCOUNT();
}
sfree(handles);
if (sending)
handle_unthrottle(stdin_handle, backend_sendbuffer(backend));
if (!backend_connected(backend) &&
handle_backlog(stdout_handle) + handle_backlog(stderr_handle) == 0)
break; /* we closed the connection */
}
exitcode = backend_exitcode(backend);
if (exitcode < 0) {
fprintf(stderr, "Remote process exit code unavailable\n");
exitcode = 1; /* this is an error condition */
}
cleanup_exit(exitcode);
return 0; /* placate compiler warning */
}
int main(int argc, char **argv) {
WSADATA wsadata;
WORD winsock_ver;
WSAEVENT stdinevent;
HANDLE handles[2];
DWORD threadid;
struct input_data idata;
int sending;
int portnumber = -1;
SOCKET *sklist;
int skcount, sksize;
int connopen;
ssh_get_password = get_password;
sklist = NULL; skcount = sksize = 0;
flags = FLAG_STDERR;
/*
* Process the command line.
*/
do_defaults(NULL, &cfg);
default_protocol = cfg.protocol;
default_port = cfg.port;
{
/*
* Override the default protocol if PLINK_PROTOCOL is set.
*/
char *p = getenv("PLINK_PROTOCOL");
int i;
if (p) {
for (i = 0; backends[i].backend != NULL; i++) {
if (!strcmp(backends[i].name, p)) {
default_protocol = cfg.protocol = backends[i].protocol;
default_port = cfg.port = backends[i].backend->default_port;
break;
}
}
}
}
while (--argc) {
char *p = *++argv;
if (*p == '-') {
if (!strcmp(p, "-ssh")) {
default_protocol = cfg.protocol = PROT_SSH;
default_port = cfg.port = 22;
} else if (!strcmp(p, "-telnet")) {
default_protocol = cfg.protocol = PROT_TELNET;
default_port = cfg.port = 23;
} else if (!strcmp(p, "-raw")) {
default_protocol = cfg.protocol = PROT_RAW;
} else if (!strcmp(p, "-v")) {
flags |= FLAG_VERBOSE;
} else if (!strcmp(p, "-log")) {
logfile = "putty.log";
} else if (!strcmp(p, "-pw") && argc > 1) {
--argc, password = *++argv;
} else if (!strcmp(p, "-l") && argc > 1) {
char *username;
--argc, username = *++argv;
strncpy(cfg.username, username, sizeof(cfg.username));
cfg.username[sizeof(cfg.username)-1] = '\0';
} else if (!strcmp(p, "-P") && argc > 1) {
--argc, portnumber = atoi(*++argv);
}
} else if (*p) {
if (!*cfg.host) {
char *q = p;
/*
* If the hostname starts with "telnet:", set the
* protocol to Telnet and process the string as a
* Telnet URL.
*/
if (!strncmp(q, "telnet:", 7)) {
char c;
q += 7;
if (q[0] == '/' && q[1] == '/')
q += 2;
cfg.protocol = PROT_TELNET;
p = q;
while (*p && *p != ':' && *p != '/') p++;
c = *p;
if (*p)
*p++ = '\0';
if (c == ':')
cfg.port = atoi(p);
else
cfg.port = -1;
strncpy (cfg.host, q, sizeof(cfg.host)-1);
cfg.host[sizeof(cfg.host)-1] = '\0';
} else {
char *r;
/*
* Before we process the [user@]host string, we
* first check for the presence of a protocol
* prefix (a protocol name followed by ",").
*/
r = strchr(p, ',');
if (r) {
int i, j;
for (i = 0; backends[i].backend != NULL; i++) {
j = strlen(backends[i].name);
if (j == r-p &&
!memcmp(backends[i].name, p, j)) {
default_protocol = cfg.protocol = backends[i].protocol;
portnumber = backends[i].backend->default_port;
p = r+1;
break;
}
}
}
/*
* Three cases. Either (a) there's a nonzero
* length string followed by an @, in which
* case that's user and the remainder is host.
* Or (b) there's only one string, not counting
* a potential initial @, and it exists in the
* saved-sessions database. Or (c) only one
* string and it _doesn't_ exist in the
* database.
*/
r = strrchr(p, '@');
if (r == p) p++, r = NULL; /* discount initial @ */
if (r == NULL) {
/*
* One string.
*/
Config cfg2;
do_defaults (p, &cfg2);
if (cfg2.host[0] == '\0') {
/* No settings for this host; use defaults */
strncpy(cfg.host, p, sizeof(cfg.host)-1);
cfg.host[sizeof(cfg.host)-1] = '\0';
cfg.port = 22;
} else
cfg = cfg2;
} else {
*r++ = '\0';
strncpy(cfg.username, p, sizeof(cfg.username)-1);
cfg.username[sizeof(cfg.username)-1] = '\0';
strncpy(cfg.host, r, sizeof(cfg.host)-1);
cfg.host[sizeof(cfg.host)-1] = '\0';
cfg.port = 22;
}
}
} else {
int len = sizeof(cfg.remote_cmd) - 1;
char *cp = cfg.remote_cmd;
int len2;
strncpy(cp, p, len); cp[len] = '\0';
len2 = strlen(cp); len -= len2; cp += len2;
while (--argc) {
if (len > 0)
len--, *cp++ = ' ';
strncpy(cp, *++argv, len); cp[len] = '\0';
len2 = strlen(cp); len -= len2; cp += len2;
}
cfg.nopty = TRUE; /* command => no terminal */
cfg.ldisc_term = TRUE; /* use stdin like a line buffer */
break; /* done with cmdline */
}
}
}
if (!*cfg.host) {
usage();
}
if (!*cfg.remote_cmd)
flags |= FLAG_INTERACTIVE;
/*
* Select protocol. This is farmed out into a table in a
* separate file to enable an ssh-free variant.
*/
{
int i;
back = NULL;
for (i = 0; backends[i].backend != NULL; i++)
if (backends[i].protocol == cfg.protocol) {
back = backends[i].backend;
break;
}
if (back == NULL) {
fprintf(stderr, "Internal fault: Unsupported protocol found\n");
return 1;
}
}
/*
* Select port.
*/
if (portnumber != -1)
cfg.port = portnumber;
/*
* Initialise WinSock.
*/
winsock_ver = MAKEWORD(2, 0);
if (WSAStartup(winsock_ver, &wsadata)) {
MessageBox(NULL, "Unable to initialise WinSock", "WinSock Error",
MB_OK | MB_ICONEXCLAMATION);
return 1;
}
if (LOBYTE(wsadata.wVersion) != 2 || HIBYTE(wsadata.wVersion) != 0) {
MessageBox(NULL, "WinSock version is incompatible with 2.0",
"WinSock Error", MB_OK | MB_ICONEXCLAMATION);
WSACleanup();
return 1;
}
sk_init();
/*
* Start up the connection.
*/
netevent = CreateEvent(NULL, FALSE, FALSE, NULL);
{
char *error;
char *realhost;
error = back->init (cfg.host, cfg.port, &realhost);
if (error) {
fprintf(stderr, "Unable to open connection:\n%s", error);
return 1;
}
}
connopen = 1;
stdinevent = CreateEvent(NULL, FALSE, FALSE, NULL);
GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &orig_console_mode);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_PROCESSED_INPUT);
outhandle = GetStdHandle(STD_OUTPUT_HANDLE);
errhandle = GetStdHandle(STD_ERROR_HANDLE);
/*
* Turn off ECHO and LINE input modes. We don't care if this
* call fails, because we know we aren't necessarily running in
* a console.
*/
handles[0] = netevent;
handles[1] = stdinevent;
sending = FALSE;
while (1) {
int n;
if (!sending && back->sendok()) {
/*
* Create a separate thread to read from stdin. This is
* a total pain, but I can't find another way to do it:
*
* - an overlapped ReadFile or ReadFileEx just doesn't
* happen; we get failure from ReadFileEx, and
* ReadFile blocks despite being given an OVERLAPPED
* structure. Perhaps we can't do overlapped reads
* on consoles. WHY THE HELL NOT?
*
* - WaitForMultipleObjects(netevent, console) doesn't
* work, because it signals the console when
* _anything_ happens, including mouse motions and
* other things that don't cause data to be readable
* - so we're back to ReadFile blocking.
*/
idata.event = stdinevent;
idata.eventback = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!CreateThread(NULL, 0, stdin_read_thread,
&idata, 0, &threadid)) {
fprintf(stderr, "Unable to create second thread\n");
exit(1);
}
sending = TRUE;
}
n = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
if (n == 0) {
WSANETWORKEVENTS things;
enum234 e;
SOCKET socket;
extern SOCKET first_socket(enum234 *), next_socket(enum234 *);
extern int select_result(WPARAM, LPARAM);
int i;
/*
* We must not call select_result() for any socket
* until we have finished enumerating within the tree.
* This is because select_result() may close the socket
* and modify the tree.
*/
/* Count the active sockets. */
i = 0;
for (socket = first_socket(&e); socket != INVALID_SOCKET;
socket = next_socket(&e))
i++;
/* Expand the buffer if necessary. */
if (i > sksize) {
sksize = i+16;
sklist = srealloc(sklist, sksize * sizeof(*sklist));
}
/* Retrieve the sockets into sklist. */
skcount = 0;
for (socket = first_socket(&e); socket != INVALID_SOCKET;
socket = next_socket(&e)) {
sklist[skcount++] = socket;
}
/* Now we're done enumerating; go through the list. */
for (i = 0; i < skcount; i++) {
WPARAM wp;
socket = sklist[i];
wp = (WPARAM)socket;
if (!WSAEnumNetworkEvents(socket, netevent, &things)) {
noise_ultralight(socket);
noise_ultralight(things.lNetworkEvents);
if (things.lNetworkEvents & FD_READ)
connopen &= select_result(wp, (LPARAM)FD_READ);
if (things.lNetworkEvents & FD_CLOSE)
connopen &= select_result(wp, (LPARAM)FD_CLOSE);
if (things.lNetworkEvents & FD_OOB)
connopen &= select_result(wp, (LPARAM)FD_OOB);
if (things.lNetworkEvents & FD_WRITE)
connopen &= select_result(wp, (LPARAM)FD_WRITE);
}
}
} else if (n == 1) {
noise_ultralight(idata.len);
if (idata.len > 0) {
back->send(idata.buffer, idata.len);
} else {
back->special(TS_EOF);
}
SetEvent(idata.eventback);
}
if (!connopen || back->socket() == NULL)
break; /* we closed the connection */
}
WSACleanup();
return 0;
}
/*
* Main program. Parse arguments etc.
*/
int main(int argc, char *argv[])
{
int i;
int portnumber = 0;
char *userhost, *user;
int mode = 0;
int modeflags = 0;
char *batchfile = NULL;
flags = FLAG_STDERR | FLAG_INTERACTIVE;
ssh_get_line = &console_get_line;
init_winsock();
sk_init();
userhost = user = NULL;
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-') {
if (userhost)
usage();
else
userhost = dupstr(argv[i]);
} else if (strcmp(argv[i], "-v") == 0) {
verbose = 1, flags |= FLAG_VERBOSE;
} else if (strcmp(argv[i], "-h") == 0 ||
strcmp(argv[i], "-?") == 0) {
usage();
} else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) {
user = argv[++i];
} else if (strcmp(argv[i], "-P") == 0 && i + 1 < argc) {
portnumber = atoi(argv[++i]);
} else if (strcmp(argv[i], "-pw") == 0 && i + 1 < argc) {
console_password = argv[++i];
} else if (strcmp(argv[i], "-b") == 0 && i + 1 < argc) {
mode = 1;
batchfile = argv[++i];
} else if (strcmp(argv[i], "-bc") == 0) {
modeflags = modeflags | 1;
} else if (strcmp(argv[i], "-batch") == 0) {
console_batch_mode = TRUE;
} else if (strcmp(argv[i], "-be") == 0) {
modeflags = modeflags | 2;
} else if (strcmp(argv[i], "--") == 0) {
i++;
break;
} else {
usage();
}
}
argc -= i;
argv += i;
back = NULL;
/*
* If a user@host string has already been provided, connect to
* it now.
*/
if (userhost) {
if (psftp_connect(userhost, user, portnumber))
return 1;
do_sftp_init();
} else {
printf("psftp: no hostname specified; use \"open host.name\""
" to connect\n");
}
do_sftp(mode, modeflags, batchfile);
if (back != NULL && back->socket() != NULL) {
char ch;
back->special(TS_EOF);
sftp_recvdata(&ch, 1);
}
WSACleanup();
random_save_seed();
return 0;
}
int main(int argc, char **argv)
{
bool sending;
int *fdlist;
int fd;
int i, fdstate;
size_t fdsize;
int exitcode;
bool errors;
enum TriState sanitise_stdout = AUTO, sanitise_stderr = AUTO;
bool use_subsystem = false;
bool just_test_share_exists = false;
unsigned long now;
struct winsize size;
const struct BackendVtable *backvt;
fdlist = NULL;
fdsize = 0;
/*
* Initialise port and protocol to sensible defaults. (These
* will be overridden by more or less anything.)
*/
default_protocol = PROT_SSH;
default_port = 22;
bufchain_init(&stdout_data);
bufchain_init(&stderr_data);
bufchain_sink_init(&stdout_bcs, &stdout_data);
bufchain_sink_init(&stderr_bcs, &stderr_data);
stdout_bs = BinarySink_UPCAST(&stdout_bcs);
stderr_bs = BinarySink_UPCAST(&stderr_bcs);
outgoingeof = EOF_NO;
flags = FLAG_STDERR_TTY;
cmdline_tooltype |=
(TOOLTYPE_HOST_ARG |
TOOLTYPE_HOST_ARG_CAN_BE_SESSION |
TOOLTYPE_HOST_ARG_PROTOCOL_PREFIX |
TOOLTYPE_HOST_ARG_FROM_LAUNCHABLE_LOAD);
stderr_tty_init();
/*
* Process the command line.
*/
conf = conf_new();
do_defaults(NULL, conf);
loaded_session = false;
default_protocol = conf_get_int(conf, CONF_protocol);
default_port = conf_get_int(conf, CONF_port);
errors = false;
{
/*
* Override the default protocol if PLINK_PROTOCOL is set.
*/
char *p = getenv("PLINK_PROTOCOL");
if (p) {
const struct BackendVtable *vt = backend_vt_from_name(p);
if (vt) {
default_protocol = vt->protocol;
default_port = vt->default_port;
conf_set_int(conf, CONF_protocol, default_protocol);
conf_set_int(conf, CONF_port, default_port);
}
}
}
while (--argc) {
char *p = *++argv;
int ret = cmdline_process_param(p, (argc > 1 ? argv[1] : NULL),
1, conf);
if (ret == -2) {
fprintf(stderr,
"plink: option \"%s\" requires an argument\n", p);
errors = true;
} else if (ret == 2) {
--argc, ++argv;
} else if (ret == 1) {
continue;
} else if (!strcmp(p, "-batch")) {
console_batch_mode = true;
} else if (!strcmp(p, "-s")) {
/* Save status to write to conf later. */
use_subsystem = true;
} else if (!strcmp(p, "-V") || !strcmp(p, "--version")) {
version();
} else if (!strcmp(p, "--help")) {
usage();
exit(0);
} else if (!strcmp(p, "-pgpfp")) {
pgp_fingerprints();
exit(1);
} else if (!strcmp(p, "-o")) {
if (argc <= 1) {
fprintf(stderr,
"plink: option \"-o\" requires an argument\n");
errors = true;
} else {
--argc;
/* Explicitly pass "plink" in place of appname for
* error reporting purposes. appname will have been
* set by be_foo.c to something more generic, probably
* "PuTTY". */
provide_xrm_string(*++argv, "plink");
}
} else if (!strcmp(p, "-shareexists")) {
just_test_share_exists = true;
} else if (!strcmp(p, "-fuzznet")) {
conf_set_int(conf, CONF_proxy_type, PROXY_FUZZ);
conf_set_str(conf, CONF_proxy_telnet_command, "%host");
} else if (!strcmp(p, "-sanitise-stdout") ||
!strcmp(p, "-sanitize-stdout")) {
sanitise_stdout = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stdout") ||
!strcmp(p, "-no-sanitize-stdout")) {
sanitise_stdout = FORCE_OFF;
} else if (!strcmp(p, "-sanitise-stderr") ||
!strcmp(p, "-sanitize-stderr")) {
sanitise_stderr = FORCE_ON;
} else if (!strcmp(p, "-no-sanitise-stderr") ||
!strcmp(p, "-no-sanitize-stderr")) {
sanitise_stderr = FORCE_OFF;
} else if (!strcmp(p, "-no-antispoof")) {
console_antispoof_prompt = false;
} else if (*p != '-') {
strbuf *cmdbuf = strbuf_new();
while (argc > 0) {
if (cmdbuf->len > 0)
put_byte(cmdbuf, ' '); /* add space separator */
put_datapl(cmdbuf, ptrlen_from_asciz(p));
if (--argc > 0)
p = *++argv;
}
conf_set_str(conf, CONF_remote_cmd, cmdbuf->s);
conf_set_str(conf, CONF_remote_cmd2, "");
conf_set_bool(conf, CONF_nopty, true); /* command => no tty */
strbuf_free(cmdbuf);
break; /* done with cmdline */
} else {
fprintf(stderr, "plink: unknown option \"%s\"\n", p);
errors = true;
}
}
if (errors)
return 1;
if (!cmdline_host_ok(conf)) {
usage();
}
prepare_session(conf);
/*
* Perform command-line overrides on session configuration.
*/
cmdline_run_saved(conf);
/*
* If we have no better ideas for the remote username, use the local
* one, as 'ssh' does.
*/
if (conf_get_str(conf, CONF_username)[0] == '\0') {
char *user = get_username();
if (user) {
conf_set_str(conf, CONF_username, user);
sfree(user);
}
}
/*
* Apply subsystem status.
*/
if (use_subsystem)
conf_set_bool(conf, CONF_ssh_subsys, true);
if (!*conf_get_str(conf, CONF_remote_cmd) &&
!*conf_get_str(conf, CONF_remote_cmd2) &&
!*conf_get_str(conf, CONF_ssh_nc_host))
flags |= FLAG_INTERACTIVE;
/*
* Select protocol. This is farmed out into a table in a
* separate file to enable an ssh-free variant.
*/
backvt = backend_vt_from_proto(conf_get_int(conf, CONF_protocol));
if (!backvt) {
fprintf(stderr,
"Internal fault: Unsupported protocol found\n");
return 1;
}
/*
* Block SIGPIPE, so that we'll get EPIPE individually on
* particular network connections that go wrong.
*/
putty_signal(SIGPIPE, SIG_IGN);
/*
* Set up the pipe we'll use to tell us about SIGWINCH.
*/
if (pipe(signalpipe) < 0) {
perror("pipe");
exit(1);
}
/* We don't want the signal handler to block if the pipe's full. */
nonblock(signalpipe[0]);
nonblock(signalpipe[1]);
cloexec(signalpipe[0]);
cloexec(signalpipe[1]);
putty_signal(SIGWINCH, sigwinch);
/*
* Now that we've got the SIGWINCH handler installed, try to find
* out the initial terminal size.
*/
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &size) >= 0) {
conf_set_int(conf, CONF_width, size.ws_col);
conf_set_int(conf, CONF_height, size.ws_row);
}
/*
* Decide whether to sanitise control sequences out of standard
* output and standard error.
*
* If we weren't given a command-line override, we do this if (a)
* the fd in question is pointing at a terminal, and (b) we aren't
* trying to allocate a terminal as part of the session.
*
* (Rationale: the risk of control sequences is that they cause
* confusion when sent to a local terminal, so if there isn't one,
* no problem. Also, if we allocate a remote terminal, then we
* sent a terminal type, i.e. we told it what kind of escape
* sequences we _like_, i.e. we were expecting to receive some.)
*/
if (sanitise_stdout == FORCE_ON ||
(sanitise_stdout == AUTO && isatty(STDOUT_FILENO) &&
conf_get_bool(conf, CONF_nopty))) {
stdout_scc = stripctrl_new(stdout_bs, true, L'\0');
stdout_bs = BinarySink_UPCAST(stdout_scc);
}
if (sanitise_stderr == FORCE_ON ||
(sanitise_stderr == AUTO && isatty(STDERR_FILENO) &&
conf_get_bool(conf, CONF_nopty))) {
stderr_scc = stripctrl_new(stderr_bs, true, L'\0');
stderr_bs = BinarySink_UPCAST(stderr_scc);
}
sk_init();
uxsel_init();
/*
* Plink doesn't provide any way to add forwardings after the
* connection is set up, so if there are none now, we can safely set
* the "simple" flag.
*/
if (conf_get_int(conf, CONF_protocol) == PROT_SSH &&
!conf_get_bool(conf, CONF_x11_forward) &&
!conf_get_bool(conf, CONF_agentfwd) &&
!conf_get_str_nthstrkey(conf, CONF_portfwd, 0))
conf_set_bool(conf, CONF_ssh_simple, true);
if (just_test_share_exists) {
if (!backvt->test_for_upstream) {
fprintf(stderr, "Connection sharing not supported for connection "
"type '%s'\n", backvt->name);
return 1;
}
if (backvt->test_for_upstream(conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port), conf))
return 0;
else
return 1;
}
/*
* Start up the connection.
*/
logctx = log_init(default_logpolicy, conf);
{
const char *error;
char *realhost;
/* nodelay is only useful if stdin is a terminal device */
bool nodelay = conf_get_bool(conf, CONF_tcp_nodelay) && isatty(0);
/* This is a good place for a fuzzer to fork us. */
#ifdef __AFL_HAVE_MANUAL_CONTROL
__AFL_INIT();
#endif
error = backend_init(backvt, plink_seat, &backend, logctx, conf,
conf_get_str(conf, CONF_host),
conf_get_int(conf, CONF_port),
&realhost, nodelay,
conf_get_bool(conf, CONF_tcp_keepalives));
if (error) {
fprintf(stderr, "Unable to open connection:\n%s\n", error);
return 1;
}
ldisc_create(conf, NULL, backend, plink_seat);
sfree(realhost);
}
/*
* Set up the initial console mode. We don't care if this call
* fails, because we know we aren't necessarily running in a
* console.
*/
local_tty = (tcgetattr(STDIN_FILENO, &orig_termios) == 0);
atexit(cleanup_termios);
seat_echoedit_update(plink_seat, 1, 1);
sending = false;
now = GETTICKCOUNT();
pollwrapper *pw = pollwrap_new();
while (1) {
int rwx;
int ret;
unsigned long next;
pollwrap_clear(pw);
pollwrap_add_fd_rwx(pw, signalpipe[0], SELECT_R);
if (!sending &&
backend_connected(backend) &&
backend_sendok(backend) &&
backend_sendbuffer(backend) < MAX_STDIN_BACKLOG) {
/* If we're OK to send, then try to read from stdin. */
pollwrap_add_fd_rwx(pw, STDIN_FILENO, SELECT_R);
}
if (bufchain_size(&stdout_data) > 0) {
/* If we have data for stdout, try to write to stdout. */
pollwrap_add_fd_rwx(pw, STDOUT_FILENO, SELECT_W);
}
if (bufchain_size(&stderr_data) > 0) {
/* If we have data for stderr, try to write to stderr. */
pollwrap_add_fd_rwx(pw, STDERR_FILENO, SELECT_W);
}
/* Count the currently active fds. */
i = 0;
for (fd = first_fd(&fdstate, &rwx); fd >= 0;
fd = next_fd(&fdstate, &rwx)) i++;
/* Expand the fdlist buffer if necessary. */
sgrowarray(fdlist, fdsize, i);
/*
* Add all currently open fds to pw, and store them in fdlist
* as well.
*/
int fdcount = 0;
for (fd = first_fd(&fdstate, &rwx); fd >= 0;
fd = next_fd(&fdstate, &rwx)) {
fdlist[fdcount++] = fd;
pollwrap_add_fd_rwx(pw, fd, rwx);
}
if (toplevel_callback_pending()) {
ret = pollwrap_poll_instant(pw);
} else if (run_timers(now, &next)) {
do {
unsigned long then;
long ticks;
then = now;
now = GETTICKCOUNT();
if (now - then > next - then)
ticks = 0;
else
ticks = next - now;
bool overflow = false;
if (ticks > INT_MAX) {
ticks = INT_MAX;
overflow = true;
}
ret = pollwrap_poll_timeout(pw, ticks);
if (ret == 0 && !overflow)
now = next;
else
now = GETTICKCOUNT();
} while (ret < 0 && errno == EINTR);
} else {
ret = pollwrap_poll_endless(pw);
}
if (ret < 0 && errno == EINTR)
continue;
if (ret < 0) {
perror("poll");
exit(1);
}
for (i = 0; i < fdcount; i++) {
fd = fdlist[i];
int rwx = pollwrap_get_fd_rwx(pw, fd);
/*
* We must process exceptional notifications before
* ordinary readability ones, or we may go straight
* past the urgent marker.
*/
if (rwx & SELECT_X)
select_result(fd, SELECT_X);
if (rwx & SELECT_R)
select_result(fd, SELECT_R);
if (rwx & SELECT_W)
select_result(fd, SELECT_W);
}
if (pollwrap_check_fd_rwx(pw, signalpipe[0], SELECT_R)) {
char c[1];
struct winsize size;
if (read(signalpipe[0], c, 1) <= 0)
/* ignore error */;
/* ignore its value; it'll be `x' */
if (ioctl(STDIN_FILENO, TIOCGWINSZ, (void *)&size) >= 0)
backend_size(backend, size.ws_col, size.ws_row);
}
if (pollwrap_check_fd_rwx(pw, STDIN_FILENO, SELECT_R)) {
char buf[4096];
int ret;
if (backend_connected(backend)) {
ret = read(STDIN_FILENO, buf, sizeof(buf));
noise_ultralight(NOISE_SOURCE_IOLEN, ret);
if (ret < 0) {
perror("stdin: read");
exit(1);
} else if (ret == 0) {
backend_special(backend, SS_EOF, 0);
sending = false; /* send nothing further after this */
} else {
if (local_tty)
from_tty(buf, ret);
else
backend_send(backend, buf, ret);
}
}
}
if (pollwrap_check_fd_rwx(pw, STDOUT_FILENO, SELECT_W)) {
backend_unthrottle(backend, try_output(false));
}
if (pollwrap_check_fd_rwx(pw, STDERR_FILENO, SELECT_W)) {
backend_unthrottle(backend, try_output(true));
}
run_toplevel_callbacks();
if (!backend_connected(backend) &&
bufchain_size(&stdout_data) == 0 &&
bufchain_size(&stderr_data) == 0)
break; /* we closed the connection */
}
exitcode = backend_exitcode(backend);
if (exitcode < 0) {
fprintf(stderr, "Remote process exit code unavailable\n");
exitcode = 1; /* this is an error condition */
}
cleanup_exit(exitcode);
return exitcode; /* shouldn't happen, but placates gcc */
}
//*****************
// MAIN
//*****************
int main (int argc, char *argv[]) {
//orologio
time_t now;
struct tm *tm_now;
char conv[3];
char buff[20];
//match
unsigned char hr;
unsigned char min;
int presa,timer;//x cicli for
//aspetta alim stabile
delay_ms(50);
sk_clear();
delay_ms(50);
system ("clear");
if (i2c_open()<0) { printf("Apertura del bus I2C fallita\n"); return 1; }
board_init(); printf("--Init board [PASS]\n");
lcd_init(); printf("--Init lcd [PASS]\n");
ciabatta_init(); printf("--Init ciabatta [PASS]\n");
// socket_init(); printf("--Init socket on 15000 [PASS]\n");
board_init();
ciabatta_init();
sk_init();
printf("\nfox-acqua in esecuzione.\n");
if(fork() != 0){ //eseguito dal processo padre
for(;;){
y_pos(1,3);
lcd_printf("MENU");
cursore_scegli_opz(3);
while(p_status()!= P_OK){
//disegna lo stato delle prese
y_pos(1,0);
lcd_printf(" P:");
for(presa=1;presa<8;presa++) lcd_printf("%d",presa_read_level(presa));
//mostra ora e data
y_pos(12,1);
now = time ( NULL );
tm_now = localtime ( &now );
//%a /* Abbreviated weekday */
//%A /* Full weekday */
//%b /* Abbreviated month */
//%b /* Full month */
//%c /* Full date and time */
//%d /* Day of the month (1-31) */
//%H /* Hour (24 hour clock) */
//%I /* Hour (12 hour clock) */
//%j /* Day of the year (1-366)*/
//%m /* Month (1-12) */
//%M /* Minute (0-59) */
//%p /* AM/PM for 12 hour clock */
//%S /* Second (0-60) */
//%U /* Week number from Sunday */
//%w /* Weekday (0-6) from Sunday */
//%W /* Week number from Monday */
//%x /* Full date */
//%X /* Full time of day */
//%y /* Year without century */
//%Y /* Year with century */
//%Z /* Time zone */
//%% /* Print a % character */
strftime ( buff, sizeof buff, "%H:%M:%S", tm_now );
strftime ( conv, sizeof conv, "%H", tm_now ); hr=atoi(conv);
strftime ( conv, sizeof conv, "%M", tm_now ); min=atoi(conv);
lcd_printf( "%s", buff );
y_pos(12,2);
strftime ( buff, sizeof buff, "%d/%m/%y", tm_now );
lcd_printf( "%s", buff );
//----match tra rtc e timer vari----
//controlla se un delle 10 prese ha un timer attivo
s_timer timer[70];
for (a=0; a<70; a++)
read_timer(&timer[a], a);
//for (presa=0;presa<8;presa++){ //sfoglia le prese
//for(timer=0;timer<10;timer++){ //sfoglia i 10 timer di questa presa
if (presa_timer_stato[presa][timer]<99){
//allora c'� un timer impostato x questa presa
//controlla se deve scattare in questo momento
// !!!!!!!!!!!!!!
// risolvere il problema nel caso in cui: l'utente sia nel menu,
// e quando si ritorna qui l'orologio � andato
// dopo l'evento di un timer.
if (presa_timer[presa][timer][0]==hr){
if (presa_timer[presa][timer][1]==min){//ok, allora imposta la presa.
presa_set_level(presa+1,presa_timer_stato[presa][timer]);
}
}
}
}
}
} //luppa fink� non � premuto
sk_clear();
//socket_printf(cs,"Menu_1_0");
//write(cs,zero,1); //fa scrivee effettivamente la frase sopra svuotando il buffer ke ha interno(penso).
sk_menu_1();
sk_clear();
}//for
int
main (int argc,
char **argv)
{
error_t err;
mach_port_t bootstrap;
struct stat st;
pthread_t thread;
pfinet_bucket = ports_create_bucket ();
addrport_class = ports_create_class (clean_addrport, 0);
socketport_class = ports_create_class (clean_socketport, 0);
mach_port_allocate (mach_task_self (), MACH_PORT_RIGHT_RECEIVE,
&fsys_identity);
/* Generic initialization */
init_time ();
ethernet_initialize ();
err = pthread_create (&thread, NULL, net_bh_worker, NULL);
if (!err)
pthread_detach (thread);
else
{
errno = err;
perror ("pthread_create");
}
pthread_mutex_lock (&global_lock);
prepare_current (1); /* Set up to call into Linux initialization. */
sk_init ();
#ifdef SLAB_SKB
skb_init ();
#endif
inet_proto_init (0);
/* This initializes the Linux network device layer, including
initializing each device on the `dev_base' list. For us,
that means just loopback_dev, which will get fully initialized now.
After this, we can use `register_netdevice' for new interfaces. */
net_dev_init ();
/* ifconfig lo up 127.0.0.1 netmask 0xff000000 */
configure_device (&loopback_dev,
htonl (INADDR_LOOPBACK), htonl (IN_CLASSA_NET),
htonl (INADDR_NONE), htonl (INADDR_NONE));
pthread_mutex_unlock (&global_lock);
/* Parse options. When successful, this configures the interfaces
before returning; to do so, it will acquire the global_lock.
(And when not successful, it never returns.) */
argp_parse (&pfinet_argp, argc, argv, 0,0,0);
task_get_bootstrap_port (mach_task_self (), &bootstrap);
pfinet_owner = pfinet_group = 0;
if (bootstrap != MACH_PORT_NULL) {
/* Create portclass to install on the bootstrap port. */
if(pfinet_protid_portclasses[pfinet_bootstrap_portclass]
!= MACH_PORT_NULL)
error(1, 0, "No portclass left to assign to bootstrap port");
#ifdef CONFIG_IPV6
if (pfinet_bootstrap_portclass == PORTCLASS_INET6)
pfinet_activate_ipv6 ();
#endif
err = trivfs_add_protid_port_class (
&pfinet_protid_portclasses[pfinet_bootstrap_portclass]);
if (err)
error (1, 0, "error creating control port class");
err = trivfs_add_control_port_class (
&pfinet_cntl_portclasses[pfinet_bootstrap_portclass]);
if (err)
error (1, 0, "error creating control port class");
/* Talk to parent and link us in. */
err = trivfs_startup (bootstrap, 0,
pfinet_cntl_portclasses[pfinet_bootstrap_portclass],
pfinet_bucket,
pfinet_protid_portclasses[pfinet_bootstrap_portclass],
pfinet_bucket,
&pfinetctl);
if (err)
error (1, err, "contacting parent");
/* Initialize status from underlying node. */
err = io_stat (pfinetctl->underlying, &st);
if (! err)
{
pfinet_owner = st.st_uid;
pfinet_group = st.st_gid;
}
}
else { /* no bootstrap port. */
int i;
/* Check that at least one portclass has been bound,
error out otherwise. */
for (i = 0; i < ARRAY_SIZE (pfinet_protid_portclasses); i++)
if (pfinet_protid_portclasses[i] != MACH_PORT_NULL)
break;
if (i == ARRAY_SIZE (pfinet_protid_portclasses))
error (1, 0, "should be started as a translator.\n");
}
/* Ask init to tell us when the system is going down,
so we can try to be friendly to our correspondents on the network. */
arrange_shutdown_notification ();
/* Launch */
ports_manage_port_operations_multithread (pfinet_bucket,
pfinet_demuxer,
30 * 1000, 2 * 60 * 1000, 0);
return 0;
}
