NetTime has no effect on bootup

A way to reliably set the clock. If NetTime did this, I wouldn’t be bothering at all.

The thing is that since it fits with what I do at work I set machines at home to use DHCP and allow the network systems to do the rest and set the time system to use NTP and allow the NTP system to set the time.
Both just work. Since other people may not do what I do and have problems it seems reasonable to suppose that something about what they do is the cause.

Question, how many of the people having time problems use manually assigned addresses?
How many use an external DNS server rather than query their router?

Standard terms so far as I know.

I bet the NTP people would say the same. It’s a bit like “lucked out” / “lucked in”.

I doubt many people would innocently assume that’s what ‘set’ actually means when clicking the button.

I actually doubt many people would notice.

I was asking about the dotquad of the address I’m using because it gives me a text file I can read/parse without having a clue about NTP from a plain wget for a file.

I don’t know if you can use wget to read NTP. It works using UDP, does wget support that?

Alternatively – you can connect to time.nist.gov and it will reply with a few bytes which are the count of seconds since UnixTime (Jan 1st 1970 IIRC).

Or, easier to parse, you can connect to time.nist.gov on port 13 and it will reply with:

56974 14-11-13 19:17:46 00 0 0 685.6 UTC(NIST) *

which is the modified Julian date, the date in YY-MM-DD format (two digit year? seriously?), the time, some code to show if the US is in winter time (0x) or summer time (5x), a flag for leap second addition at the end of the day (0=none, 1=add, 2=remove), a “server health” report (if non-zero, don’t trust the time given), how many milliseconds the time was advanced for network delays, "UTC(NIST)" for timezone and origin (this does not change), and a “*” at the end to mean “it is this time now” or something. I’ve telnetted to the server a dozen times and the star is always there, maybe the server delays replying until the time is exactly as given?

Since other people may not do what I do and have problems it seems reasonable to suppose that something about what they do is the cause.

Err… So we are blaming the users because there is no “just set the time and shuttup” option? ;-)

At the very least, RISC OS probably ought to trap/fault dates prior to 2014.

Question, how many of the people having time problems use manually assigned addresses?

For what? The client? The gateway? The DNS? The time server? “All of the above”?

Err… So we are blaming the users because there is no “just set the time and shuttup” option? ;-)

Looking for triggers. When diagnosing there is no right or wrong, merely “this” “that” and “the other”

At the very least, RISC OS probably ought to trap/fault dates prior to 2014

Check the code – I believe it has an NTP zero point of “2003 ish”
However, short of waiting for me to learn C¹ I would suggest someone else tries fiddling with it…

For what? The client? The gateway? The DNS? The time server? “All of the above”?

Well I was thinking client, but since you mention it “all of the above” :)

Information is the key.

¹ Somewhere comparable in duration to the time required for RISC OS being fully multi-threaded running on 32 core systems may be adequate

Check the code – I believe it has an NTP zero point of “2003 ish”

This doesn’t appear to be borne out by Martin’s experience if NetTime fails and the date is left at 1970.

Somewhere comparable in duration to the time required for RISC OS being fully multi-threaded running on 32 core systems may be adequate

I wouldn’t wager on that – it would be a little less than sane for a group of interested companies to design a board for use with RISC OS that has a multi-core processor and not be planning (at some random future date) to make use of all of the resources available. As we know, ROOL had support for the Pi B+ ready for the release of the B+, so for all we know the intelligent coders here¹ are already bashing out a specification to implement. Which is probably better than asking opinions on a forum! ;-)

Aaaanyway – I rather suspect that for some seemingly random reason, Martin’s time fetching fails. Like how sometimes when my EeePC connects to the Livebox, it ends up with the address 169.254.0.1. To dig in further, Martin would need to immediately look at all of his IP configuration values (I think *Show Inet* would list most of them) to see if that is where the problem lies. And then to query NetTime to see if it actually managed to contact a server. And so on. Some small random hiccup.
Unfortunately for him, it being his primary clock source (or so it seems – to be 1970 I guess he doesn’t have an RTC), a failure means the time doesn’t get set, so the clock stays at its default, which causes problems further down the line.

Given that this has happened more than once², and given that it has caused loss of data, if I was Martin I would write a small program to either abort the boot if the clock was set way in the past, or (if using BASIC), just call OS_Reset if the clock is bad. Sure, this might leave the machine in a loop of constant resets if the network is down, so add in a check for INKEY(-3) to override this if an ALT key is held down. Or hammer ESC as RISC OS starts. Either will get you to a desktop. ;-)

¹ Which pretty much rules me out then!

² I cannot say if my NetTime fails. It provides no obvious notification other than the possibility that the RTC won’t be exactly accurate; but without constantly comparing it to something… unlike with Windows, there is no clock on my iconbar, so it could be minutes out and I wouldn’t know.

The thing is that since it fits with what I do at work I set machines at home to use DHCP and allow the network systems to do the rest and set the…

What you say makes sense but probably examples a critical assumption behind NetTime.

In essence it takes for granted that the user will be in a situation like the one you outline. Having a set of connected machines that are essentially ‘always on’ and you need to closely synch their times as well as have those times close to external references.

But I normally only turn on a machine when I want to use it. Use it. Then switch it off again. So generally one machine on at a time, and no need to synch them with great precision. And most of the time, all the machines are powered down.

In this context what NetTime does is futile. It tries to ‘set’ the clock by actually nudging the rate. But long before that magical future state of perfection, I’ve powered down the machine and its back on its hardware real time clock. Since my experience is that even when minutes in error it often fails to actually set the clock, its useless.

Because it makes assumptions about my situation which are wrong and doesn’t cater for my real situation. All made worse by the misleading ‘set’ claim.

So for some people, its fine. For others it is practically useless. Worse if people think it has really set the clock and need it to have done so but it didn’t.

Jim

Rick:

Again, my apologies but a lot of what you explain wrt being able to connect, etc, I simply don’t know how to do. You are assuming I know what it meant by things like:

you can connect to time.nist.gov on port 13 and it will reply with:
56974 14-11-13 19:17:46 00 0 0 685.6 UTC *
which is the modified Julian date, the date in YY-MM-DD format (two digit year?

But I don’t. “Connect” how? I have no real understanding of how to do such things at present. So when I look at things people point me to I don’t even know the language a lot of the time.

I accept this is my ignorance, and aplogise for it, but it means I’m unclear how to proceed.

If I understood I might be able to make something that behaves (from the user’s POV) like the old !FreeTime. But when I look at that I get lost for similar reasons. I can follow each line of ‘C’ but not what they actually do at this level.

Jim

So, can someone explain or point me to a simple explanation of how to do what I say I don’t understand above? I’d welcome help.

Jim

I got that information simply by using telnet to the appropriate address and port. I don’t know if wget will do this. If not, perhaps I could put something together? It’s a simple open connection, read data, close type of thing… You might be able to have a crack at it by looking at the code that you already have?

I have a port of wget which allows me to give it a URL and fetch a file. But I’ve only managed to get this to work with http://… addresses to fetch html or text pages. i.e. Much like using a browser, but saves just the specified file to a local file.

I don’t have a specific telnet program.

I’ve looked at the innards of !FreeTime but don’t understand it well enough to attempt to try using parts as a basis for something new that might work.

How would I use a telnet like connection with wget? Change the http:// part to something else? Or does that make no sense and I need something specific?

FWIW The method I’m using at present simply issues a command for wget of the form

wget -i <TimeWget$urlfile> -P <TimeWget$ResultsDir> -O <TimeWget$ResultsDir>.navytime -o <TimeWget$ResultsDir>.report

in a TaskWindow

having had !Boot define

Set TimeWget$Dir <Obey$Dir)
Set TimeWget$ResultsDir <Obey$Dir>.Results
Set TimeWget$urlfile <Obey$Dir>.timeurl

The ‘timeurl’ file contains

http://tycho.usno.navy.mil/cgi-bin/timer.pl

So all I do at present is use wget with no real idea how wget’s actual code operates above it being a ‘black box’.

It clearly isn’t satisfactory as sometimes I get nothing back. But when it works I get a ‘navytime’ file which specifies the time from their clock, datestamped with my local machine’s time. Its clumsy, but the best I’ve managed. At least it lets me set the time. If I can find a better way I can then have the process either timeout or set the time after asking if the user wants it and the error is more than a user-defined amount.

Jim

FWIW I just tried

*wget ftp://time.nist.gov:13 --2014-11-20 13:57:43-- ftp://time.nist.gov:13/ => '.listing' Resolving time.nist.gov... 24.56.178.140 Connecting to time.nist.gov|24.56.178.140|:13... connected. Logging in as anonymous ... Error in server response, closing control connection. Retrying.

And it just retried and failed a few times. So I’m obviously doing something wrong or the above isn’t able to work. So far as I know the wget only uses http and ftp. I’m guessing how to add the port number because I recall using a colon or similar for radio streams. But you can see I don’t know much about this area! :-/

I also looked at the list of *nix ports but no telnet. Long time since I’ve used it. Is there a current RO program for it?

Apologies again for the ignorance.

Jim

I knew I shouldn’t have forgotten about this thread again. In my absence, a lot of Chinese whispers seem to have gone about regarding the nature of my problem.

To elaborate:

• I do have a battery-backed RTC.
• NetTime is not my only time source.
• The problem is 100% repeatable…
• …but, because I have a battery-backed RTC, it only actively causes problems when the battery fails (which is annoyingly often).

I’ve confirmed through boot sequence hackery in the past that the TimeSetup file and whatever I’m currently using to issue the NetTime_Kick command are being executed, in their entirety, after the network has been initialised. I do not believe race conditions are a plausible answer, because the network setup happens in PreDesk and NetTime is run in Tasks, and while the boot sequence does have non-deterministic elements one of the few things it does guarantee is that everything in PreDesk happens before everything in Tasks. (I should know, I had to go to some lengths to exploit this in MBBack.)

FWIW I’ve been experimenting with !HearSay to telnet. That works OK for getting a response from nist showing the time. But I’ve only managed that in a terminal and there are now no manuals explaining the scripting system or how I might get it to run the same fetch as something I can launch and then use the result to set the time. David Pilling has said I can probably do it via a block driver. But I have zero understanding of that!

I’ve also tried an ancient ‘telnet’ absolute. This works. But I have no idea of its ancestry. Hence could not distribute it, or even be sure it is OK for me to use it. And it requires Aemulor as it isn’t 32-bit.

Anyone able to advise?

Jim

In I have some time tonight, I’ll throw together something for you when waiting for Akatsuki no Yona.
You have the DDE don’t you? This will be straight C…

Hi Rick,

Yes, I have and use the ‘Acorn’ set of C/C++, etc, as now supplied by ROOL.

Thanks. :-) And apologies again that I’m so clueless about this area!

Jim

Right-o. I would have been quicker, but something messed up files on my SD card. Recovered most of the animé (and copied off to harddisc), refetched the damaged files. And Yona. ;-)

Here is the C file:

/* JimTime

   Name     : JimTime

   Version  : 0.01

   Date     : Tuesday, 25th November 2014

   Started  : Tuesday, 25th November 2014

   Purpose  : Retrieves textual network time for Jim Lesurf
              htt ps://ww w.riscosopen.org/forum/forums/4/topics/2740
              [URL above munged - stupid Textile detects that it is a URL
               and tries to wrap it as a link, within pre text. FAIL!]

   Copyright: © 2014 Richard Murray
              <heyrick1973 -at- yahoo -dot- co -dot- uk>

   Licence  : Released under EUPL v1.1 (only).

*/

#include <stdio.h>                     // Basic I/O, every program needs this
#include <stdlib.h>                    // Basic C library functions
#include "kernel.h"                    // Kernel facilities (for SWI calls)
#include "swis.h"                      // RISC OS SWIs
#include "TCPIPLibs:socklib.h"         // Socket functions
#include "TCPIPLibs:sys.errno.h"       // Error defs
#include "TCPIPLibs:sys.socket.h"      // Miscellaneous socket stuff
#include "TCPIPLibs:netinet.in.h"      // sockaddr_in definition
#include "TCPIPLibs:netdb.h"           // Resolver
#include "TCPIPLibs:unixlib.h"         // For bcopy()


int  handle = -1;                      // Socket handle
int  mytime = 0;                       // For timeout
char buffer[32];                       // Buffer for resultant string



void tidyup(void)
{
   if (handle != -1)
   {
      socketclose(handle);
      handle = -1;
   }
   return;
}



int  main(void)
{
   struct       sockaddr_in server;    // IP address of server
   struct       hostent *rb = 0;       // Resolver data block
   int          returncode = 0;        // Return code from socket ops
   _kernel_swi_regs r;                 // For SWI calls

   // Check that the stack is loaded (in case a mesolithic era machine)
   r.r[0] = 0;
   r.r[1] = (int)"Socket_Creat";
   _kernel_swi(OS_SWINumberFromString, &r, &r);
   if (r.r[0] != 0x41200)
   {
      printf("No internet stack loaded!\n");
      exit(EXIT_FAILURE);
   }

   // Ensure Resolver is loaded
   r.r[0] = 0;
   r.r[1] = (int)"Resolver_GetHostByName";
   _kernel_swi(OS_SWINumberFromString, &r, &r);
   if (r.r[0] != 0x46000)
   {
      printf("No internet resolver loaded!\n");
      exit(EXIT_FAILURE);
   }

   // Resolve the domain - hardwired to time.nist.gov
   rb = gethostbyname("time.nist.gov");
   if (rb == 0)
   {
      printf("Cannot resolve \"time.nist.gov\".\n");
      exit(EXIT_FAILURE);
   }

   // Create the socket
   handle = socket(AF_INET, SOCK_STREAM, 0);
   if (handle == -1)
   {
      printf("Cannot create a socket handle.\n");
      exit(EXIT_FAILURE);
   }

   // Now set up a handler to catch this upon unexpected exits
   atexit(tidyup);

   // Set up the IP address block for connection
   bzero((char *)&server, sizeof(server));
   bcopy(rb->h_addr, &server.sin_addr, rb->h_length);
   server.sin_family = AF_INET;
   server.sin_port = htons(13);

   // Do the connection
   returncode = connect(handle, (struct sockaddr *)&server, sizeof(server));
   if (returncode < 0)
   {
      printf("Connection failed - error code = %d.\n", errno);
      exit(EXIT_FAILURE);
   }

   // Wait a second
   r.r[0] = 5;
   _kernel_swi(Hourglass_Start, &r, &r); // force quick display
   _kernel_swi(OS_ReadMonotonicTime, &r, &r);
   mytime = r.r[0] + 100;
   do
   {
      _kernel_swi(OS_ReadMonotonicTime, &r, &r);
   } while (mytime > r.r[0]);
   _kernel_swi(Hourglass_Off, &r, &r);

   // Read what is there for us, and close the socket (no more data to come)
   returncode = socketread(handle, &buffer, 32);
   socketclose(handle);
   handle = -1;
   if (returncode == 0)
   {
      printf("No data provided.\n");
      exit(EXIT_FAILURE);
   }

   printf("time.nist.gov says:\n%s\n:-)\n", buffer);

   exit(EXIT_SUCCESS);

   return(0); // to keep the compiler happy
}

And here is the MakeFile that builds it:

# Project:   JimTime 


# Toolflags:
CCflags      = -c -depend !Depend -I,C:,TCPIPLibs: -apcs 3/32bit -Wcdp -throwback -fan 
Linkflags    = -aif -o $@ 
Linkmodflags = -m -o $@ 
ObjAsmflags  = -APCS 3/32bit -desktop -Depend !Depend -ThrowBack -Stamp -IC:,
Squeezeflags = -f -o $@

# Source files used
c_files   = o.jimtime
s_files   = 

# How to build
@.JimTime: $(c_files) $(s_files) TCPIPLibs:o.Socklib TCPIPLibs:o.Inetlib TCPIPLibs:o.Unixlib C:o.stubs  
           link $(linkflags) $(c_files) $(s_files) TCPIPLibs:o.Socklib TCPIPLibs:o.Inetlib TCPIPLibs:o.Unixlib C:o.stubs 
           #squeeze $(Squeezeflags) @.JimTime


# A macro for building the C code
.c.o:;       cc $(ccflags) $< -o $@


# A macro for building the assembler code
.s.o:;       objasm $(objasmflags) -from $< -to $@


# Dynamic dependencies:

When run, it does this:

*JimTime
time.nist.gov says:

56986 14-11-25 20:27:33 00 0 0 
:-)
*

So, it’s up to you to parse the data sent. I described the format a few messages back. It looks like a constant format, so plucking out stuff to sent to atoi() should work. If it was me, I would do this:

• Change "14-11-25 20:27:33 " to be “14[00]11[00]25[00]20[00]27[00]33[00]” (in other words, poke in a bunch of nulls)
• Read out the data (YY, MM, DD, HH, MM, SS) using atoi().
• Munge that into actual date values, and sanitise (reject bogus dates).
• Create an ordinals data block and pass the block to Territory_ConvertTimeFormats, specifying both the output and input as being UTC, and that you want a five-byte (UTC) time returned to you.
• Finally, pass the five byte UTC time to Territory_SetTime.

You may need to play around with DST. I don’t know if RISC OS (Territory) is smart enough to set this by itself when given a within-DST date.
Ignore the DST marker in the data returned from the server, it changes according to the American method.

Okay, I’m going to click “Save reply” and see how much Textile messes this up. ;-) [edit: could have been worse…]

Thanks, Rick! :-)

Jim

Sorry to be such a numpty, but I’ve having a problem which I guess stems from my never
using Make or Makefiles at all!

I saved the above from

1. Project JimTime


1. Dynamic dependencies


(The above lines should start with hashes but textile turns them
into 1’s.)

and typed it as a MakeFile. Then put the main C code into a c directory beside it along with o and h directories.

Running the MakeFile give an error

Format of make file is incorrect

then displays a window with the lines

cc -c -depend !Depend -I,C:,TCPIPLibs: -apcs 3/32bit -Wcdp -throwback -fan c.jimtime -o o.jimtime
AMU: * No writable memory at this address *

Jim

There are two things here.

Firstly, by typing the makefile as a MakeFile and double clicking on it, it is probably being handled by the AcornC/C++ !Make application. However, the format of the makefile is not that which would be expected by !Make. You should probably be running AMU directly (from an obey file). Something like

should do it.

The error ‘No writable memory at this address’ is most likely due to the Next wimpslot being too small. On modern machines it make sense to keep the Next slot to something like 5000K. I find in general that a next slot of 7000K eliminates the occurrence of this error when running binaries.

Bingo. Yes!

Thanks, Chris. That works OK.

Afraid I’ve simply never used either Make or amu. My own programs are simply enough to just either
shove the lot into the main c file or add a few h/c files or references as suit.

It now works as Rick explained and I can do some experiments.

Many thanks,

Jim

Reply superseded & now deleted, except one can’t.

My own programs are simply enough to just either shove the lot into the main c file or add a few h/c files or references as suit.

Your programs must be fairly simple then. ;-) When it comes to including other libraries (you’ll notice the Internet stuff pulls in three libraries!) or splitting the code up into modules of related functions, you’ll find MakeFiles are invaluable. It’s a lot of horrid fiddling around otherwise.

I suspect Acorn only gave us !Make to handle programs written elsewhere. Make is awful – stupid pile of junk is only too happy to whinge about MakeFiles that it created. Sheesh!
I think the biggest testament to how horrible Make is is that Acorn wrote and supplied AMU. Need we say more? ;-)

The error ‘No writable memory at this address’ is most likely due to the Next wimpslot being too small.

I wouldn’t know. Yes, that is the reason, but when I need to compile a project, I just hit Ctrl-Shift-C in !Zap and Zap saves the file and starts the build process. I can’t remember the last time I started a build manually.

It now works as Rick explained and I can do some experiments.

Let us know when you have something good that sets the time reliably. ;-)
Extra brownie points if it works cross-territory so won’t be flummoxed by CET/CEST. Territory is your friend!

You should probably be running AMU directly (from an obey file).

Firstly, very much on baby steps myself, however I like nice repeatable setups.

This obey file seems to work nicely if the file is in the same directory as the Makefile and gives you nice helpful reports of errors and warnings (if you have an editor that allows throwback like StrongED)

Dir <Obey$Dir>
Wimpslot 5000K
amu_machine all THROWBACK=-throwback COMPONENT=yourtargetfile

Note: no amu -f required if your obey file sits in the same directory as the makefile and you change to that directory, however specifying the makefile is good practice.

As others have intimated making sure the file type of the makefile is NOT “makefile” is helpful in not using !Make. Text file &FFF is a good one to use as editing becomes easier :) probably not the recommended method.

I’d also say that Rick including the objasm line for something that doesn’t appear to contain any assembler is a bit misleading when offering help for someone who has already stated they don’t understand most of this stuff.
The standardised makefiles used in the disc and rom builds tend to use standardised includes to set appropriate flags and include appropriate library references so an early part of the makefile would be something like:

include CApp

LIBS = tbox:o.wimplib tbox:o.eventlib tbox:o.toolboxlib oslib:o.oslib

That include CApp includes the makefile elements required for a C app.
If it’s wrong then the build directories from ROOL are wrong :)

Of course you have to download a build directory from ROOL and set it up as per instructions on the site. Thereafter you can create directories with a simple makefile and obey file. Creation of required directories like “o” and “od” etc is done automatically.

This will even clean up old stuff and build a new – handy when you’re fiddling with multiple build attempts and looking for build errors.

Dir <Obey$Dir>
amu_machine clean
stripdepnd
Wimpslot 5000K
amu_machine all THROWBACK=-throwback COMPONENT=

Building Rick’s source is very easy, I am using the recently released DDE25.

Filetype the “MakeFile” as text, run !Amu, drop the makefile on !Amu. Job done.

P.S. Oops, missed a bit, an ‘o’ directory needs to be created alongside the ‘c’ source directory.

I’d also say that Rick including the objasm line for something that doesn’t appear to contain any assembler is a bit misleading when offering help for someone who has already stated they don’t understand most of this stuff.

It is a copy of the “standard” (for me) MakeFile that I have been using for nearly two decades.

That include CApp includes the makefile elements required for a C app.

Good grief – have you read what is in CApp?

I can understand the attraction of using a standardised set of MakeFiles, but stuff like that isn’t going to teach somebody how a MakeFile actually works, specifically if they wish to try modifying it to suit themselves (and/or other projects).

You may think that specifying objasm stuff is OTT, however if you have an assembler source and you write the names of the related object files into the “s_files” entry, it will “just work” and build the project. I don’t know why you specify the object instead of the source, MakeFiles are annoying like that, but it is a minor thing.
In this project, I should have put the libraries in their own definition. However I don’t tend to need to include more than DeskLib and CLib, so I tend to habitually do it as shown above.

This will even clean up old stuff and build a new – handy when you’re fiddling with multiple build attempts and looking for build errors.

You can do that with a few tweaks to the MakeFile. :-)
Sorry, I have “survived” build processes in the DOS x86 world. I really don’t like things that try to do “clever stuff” behind my back (or you need to follow convoluted logic to understand what it is trying to do). I prefer to keep it simple and self contained.

Filetype the “MakeFile” as text, run !Amu, drop the makefile on !Amu. Job done.

That’s about the only detail I’ve understood, so I’ll do that in future. Had no idea that ‘Make’ and
‘amu’ were totally different, etc!

Your programs must be fairly simple then. ;-)

Afraid so! :-)

In general I shove everything into one ‘C’ file. Only exceptions are that I have a couple
of added files (for plotting onscreen or generating drawfiles) that I put into the ‘h’
directory when needed. Most of my programs do one tiny thing that doesn’t need more than
a few of the usual includes from placed like stdio, etc.

I’m hoping to produce a simple program that will get the ‘net’ time, and compare it
with the ‘local’ time. Then offer to set the clock if they differ. All via a TaskWindow.
Not yet looked at how to handle timezones. I’ll be pleased if I can just do that, automated
to cope with BST/GMT!

If I get anywhere I will make the results available for other to chuckle over or adapt
or even use if they wish. That’s assuming Rick is happy for me to do so given his
input is crucial. (Don’t know what the conditions are for the ‘EUPL’.)

I was tempted to ask for a pointer to an idiot’s guide to amu. But I decided that
I know myself well enough that in future I’ll probably just tend to stick with my own
very ingrained plain approach despite any (brief) good intent on my part. 8-]

Thanks,

Jim