time function in C - c

In shell scripting, when ever I want the local time I do something like
date +%s
from the command line and it returns me the current date and time in this format "1343221713"
I am wondering whether there is a way to achieve the same result in C

Use time.h library in C
example:
#include <stdio.h>
#include <time.h>
int main()
{
/* Obtain current time as seconds elapsed since the Epoch. */
time_t clock = time(NULL);
/* Convert to local time format and print to stdout. */
printf("Current time is %s", ctime(&clock));
return 0;
}
see more examples:
http://en.wikipedia.org/wiki/C_date_and_time_functions

More flexible than time(3) is gettimeofday(3) as declared in sys/time.h
#include <sys/time.h>
#include <stdio.h>
int main(void)
{
struct timeval tv = {0};
gettimeofday(&tv, NULL);
printf("seconds since epoch %ld, microseconds %ld\n", tv.tv_sec, tv.tv_usec);
return 0;
}

Related

How to get current time match with timezone changes in C

I am working on an Linux based router. I am working on a C application. I want to get current time in my application continuously.
The problem is, it gives me time according to the application launch timezone although I have changed timezone after the application started. The timezone of the system has been changed. The date command on Linux terminal shows different timezone and date/time.
time_t currTm;
struct tm *loctime;
char udrTime[50];
while (1)
{
currTm = time(NULL);
loctime = localtime(&currTm);
strftime(udrTime, sizeof(udrTime), "%Y-%m-%d %H:%M:%S", loctime);
printf("udr_time = %s\n", udrTime);
usleep(10000);
}
I expect output according to timezone changes.
To change the timezone from within the application just set TZ environment variable, nothing else is necessary:
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
void print_time(time_t t) {
char buf[256];
strftime(buf, sizeof buf, "%H:%M:%S", localtime(&t));
printf("%s %s\n", getenv("TZ"), buf);
}
int main() {
time_t t = time(NULL);
setenv("TZ", "Europe/London", 1);
print_time(t);
setenv("TZ", "America/New_York", 1);
print_time(t);
return 0;
}
Outputs:
Europe/London 15:48:58
America/New_York 10:48:58

Converting a UNIX Timestamp to seconds/minutes/hours/months/years using C

Using C, I want to convert a UNIX Timestamp number to several usual date data.
How do I convert a UNIX timestamp like 12997424 to different numbers representing seconds, minutes, hours and days while using C?
Use gmtime or localtime from standard library. Prototypes are defined in time.h.
ADDED & EDITED:
So for example, the following code prints current timestamp, hour and minute:
#include <stdio.h>
#include <time.h>
void main() {
time_t t;
struct tm ttm;
t = time(NULL);
printf("Current timestamp: %d\n", t);
ttm = * localtime(&t);
printf("Current time: %02d:%02d\n", ttm.tm_hour, ttm.tm_min);
}
Here's an example of how to use localtime to convert time_t to tm as local time (credit goes to www.cplusplusreference.com):
#include <stdio.h>
#include <time.h>
int main() {
time_t rawtime;
struct tm * timeinfo;
time (&rawtime);
timeinfo = localtime (&rawtime);
printf ("Current local time and date: %s", asctime(timeinfo));
return 0;
}

How do I update a time displayed in C?

I'm trying to display the time, then wait for a period of time, then display the updated time. My code however prints the same time, without updating it.
this is my code so far:
#include<stdlib.h>
#include<time.h>
#include<sys/time.h>
int main(){
time_t timer;
time(&timer);
struct tm* time;
time = localtime(&timer);
printf("%s", asctime(time));
fflush(stdout);
sleep(4); //my attempt at adjusting the time by 4 seconds
time = localtime(&timer); // "refreshing" the time?
printf("%s", asctime(time));
return(0);
}
and my output is:
ubuntu#ubuntu:~/Desktop$ ./tester
Sat Feb 25 08:09:01 2012
Sat Feb 25 08:09:01 2012
ideally, i'd be using ctime(&timer) instead of localtime(&timer), but I'm just trying to adjust the time by 4 seconds for now. Any help would be appreciated.
localtime just converts a (pointer to) struct timep to a struct tm, it doesn't check what time it is at all.
Just call time(&timer) after the sleep if you want the new current time, and don't give a local variable the same name as a library function you're using in that same block.
(And you're missing two headers - <stdio.h> for printf, and <unistd.h> for sleep - make sure you enable warnings on your compiler.)
#include<stdlib.h>
#include<time.h>
#include<sys/time.h>
#include <stdio.h>
int main(){
time_t timer;
time(&timer);
struct tm* time_real;//time is function you can't use as variable
time_real = localtime(&timer);
printf("%s", asctime(time_real));
sleep(4);
time(&timer);//update to new time
time_real = localtime(&timer); // convert seconds to time structure tm
printf("%s", asctime(time_real));
return(0);
}

system time setting using c library function

I can get the system time using struct tm and time(),localtime(),asctime().but i need help about how i can set time of system using c program.
if you don't want to execute a shell command you can (as you mentioned) use the settimeofday, i would start by reading the MAN page, or looking for some examples
here's an example:
#include <sys/time.h>
#include <stdio.h>
#include <errno.h>
int main(int argc, char *argv[])
{
struct timeval now;
int rc;
now.tv_sec=866208142;
now.tv_usec=290944;
rc=settimeofday(&now, NULL);
if(rc==0) {
printf("settimeofday() successful.\n");
}
else {
printf("settimeofday() failed, "
"errno = %d\n",errno);
return -1;
}
return 0;
}
Shamelessly ripped From IBMs documentation, the struct timeval struct holds the number of seconds (as a long) plus the number of microseconds (as a long) from 1 January 1970, 00:00:00 UTC (Unix Epoch time). So you will need to calculate these numbers in order to set the time. you can use these helper functions, to better handle dealing with the timeval struct.

get the current time in seconds

I am wondering is there any function that would return the current time in seconds, just 2 digits of seconds? I'm using gcc 4.4.2.
The following complete program shows you how to access the seconds value:
#include <stdio.h>
#include <time.h>
int main (int argc, char *argv[]) {
time_t now;
struct tm *tm;
now = time(0);
if ((tm = localtime (&now)) == NULL) {
printf ("Error extracting time stuff\n");
return 1;
}
printf ("%04d-%02d-%02d %02d:%02d:%02d\n",
tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec);
return 0;
}
It outputs:
2010-02-11 15:58:29
How it works is as follows.
it calls time() to get the best approximation to the current time (usually number of seconds since the epoch but that's not actually mandated by the standard).
it then calls localtime() to convert that to a structure which contains the individual date and time fields, among other things.
at that point, you can just de-reference the structure to get the fields you're interested in (tm_sec in your case but I've shown a few of them).
Keep in mind you can also use gmtime() instead of localtime() if you want Greenwich time, or UTC for those too young to remember :-).
A more portable way to do this is to get the current time as a time_t struct:
time_t mytime = time((time_t*)0);
Retrieve a struct tm for this time_t:
struct tm *mytm = localtime(&mytime);
Examine the tm_sec member of mytm. Depending on your C library, there's no guarantee that the return value of time() is based on a number of seconds since the start of a minute.
You can get the current time with gettimeofday (C11), time (Linux), or localtime_r (POSIX); depending on what calendar & epoch you're interested. You can convert it to seconds elapsed after calendar epoch, or seconds of current minute, whichever you are after:
#include <stdio.h>
#include <string.h>
#include <time.h>
int main() {
time_t current_secs = time(NULL);
localtime_r(&current_secs, &current_time);
char secstr[128] = {};
struct tm current_time;
strftime(secstr, sizeof secstr, "%S", &current_time);
fprintf(stdout, "The second: %s\n", secstr);
return 0;
}
You want to use gettimeofday:
man 2 gettimeofday
#include <stdio.h>
#include <sys/time.h>
int main (int argc, char **argv)
{
int iRet;
struct timeval tv;
iRet = gettimeofday (&tv, NULL); // timezone structure is obsolete
if (iRet == 0)
{
printf ("Seconds/USeconds since epoch: %d/%d\n",
(int)tv.tv_sec, (int)tv.tv_usec);
return 0;
}
else
{
perror ("gettimeofday");
}
return iRet;
}
This is better to use then time(0), because you get the useconds as well, atomically, which is the more common use case.

Resources