WiredRevolution.com » C

Find controlling terminal with ttyname

Ryan — Thu, 06 Nov 2008 13:08:37 +0000

You can identify the path the the controlling terminal device path for your current process in C with the ttyname() system call. This controlling terminal can be a virtual console (/dev/ttyn) or a pseudo-terminal (/dev/pts/n).

The ttyname system call takes the following format.

char *ttyname(int fd);

The stdin, stdout, stderr file descriptors unless redirected are by default mapped to the controlling terminal. So for example you can pass it the stdin file descriptor.

char * pathname;
pathname = ttyname(0);

printf("controlling terminal : %s\n", pathname);

controlling terminal : /dev/pts/0

Find IP address from remote end of a TCP socket

Ryan — Fri, 31 Oct 2008 12:49:34 +0000

In C or C++ it is fairly simple to find the IP address of the remote end of a TCP socket.

The following example shows how to do this using the getpeername() and inet_ntoa() system calls.

int sockfd;
int len;
char * hostip;
struct sockaddr_in sin;

len = sizeof(sin);

if (0 != getpeername(sockfd, (struct sockaddr *) &sin, &len))
        perror("getpeername");
}

hostip = inet_ntoa(sin.sin_addr);

printf("client IP: %s\n", hostip);

Display hostname and IP address in C

Ryan — Sat, 18 Oct 2008 12:54:53 +0000

Here is a good way to determine the hostname and IP address of the local machine in C.

You first have to grab the hostname with gethostname().

char hostbuf[256];
gethostname(hostbuf,sizeof(hostbuf));

Take the hostname and use it to grab the hostent struct with gethostbyname().

struct hostent *hostentry;
hostentry = gethostbyname(hostbuf);

Finally you have to take the hostent that is returned and pull out the IP address. It is in network byte order, so you have to convert it to a string with inet_ntoa().

char * ipbuf;
ipbuf = inet_ntoa(*((struct in_addr *)hostentry->h_addr_list[0]));

Put all this together into a working programs.

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

int main()
{
        char hostbuf[256];
        char * ipbuf;
        struct hostent *hostentry;
        int ret;

        ret = gethostname(hostbuf,sizeof(hostbuf));

        if(-1 == ret){
                perror("gethostname");
                exit(1);
        }

        hostentry = gethostbyname(hostbuf);

        if(NULL == hostentry){
                perror("gethostbyname");
                exit(1);
        }

        ipbuf = inet_ntoa(*((struct in_addr *)hostentry->h_addr_list[0]));

        if(NULL == ipbuf){
                perror("inet_ntoa");
                exit(1);
        }

        printf("Hostname: %s Host IP: %s\n", hostbuf, ipbuf);

        return 0;
}

Format output using printf

Ryan — Sat, 04 Oct 2008 13:18:54 +0000

printf and its family of functions allow you to easily format string data. There are so many formatting options that it is easy to miss some of its more powerful functionality. Here is a rundown of the more useful features and some examples.

The basic printf format.

printf(format string, format parameter list);

The format string is composed of a literal string that may include one or more conversion specifiers. These all begin with ‘%’ and have the format below.

%[flags][minimum field width][precision/max field width][length]conversion specifier

flags

# The value should be converted to an ”alternate form”. For o, x or X specifiers the value is preceeded with 0, 0x or 0X respectively. For e, E and f, it forces the written output to contain a decimal point. For g or G the result is the same as with e or E but trailing zeros are not removed.
0 The value should be zero padded.
- The converted value is to be left justified.
‘ ‘ (a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.
+ A sign (+ or -) should always be placed before a number produced by a signed conversion. By default a sign is used only for negative numbers.
‘ Thousands grouping.

minimum field width

A minimum field width. If the converted value has fewer characters than the field width, it will be padded with spaces on the left (or right, if the left-adjustment flag has been given). If the result of a conversion is wider than the field width, the field is expanded to contain the conversion result.

precision/max field width

An optional precision, in the form of a period ‘.’ followed by a number which represents the maximum number of significant digits, or the maximum number of characters to be printed from a string.

length

hh char
h short
l long
ll long long
L long double
j intmax_t, uintmax_t
z size_t, ssize_t
t ptrdiff_t

conversion specifier

d,i The int argument is converted to signed decimal notation.
u An unsigned int.
o,x,X An unsigned octal (o), or unsigned hexadecimal (x and X) notation.
e,E The double [-]d.ddde±dd where there is one digit before the decimal-point character and the number of digits after it is equal to the precision. if the precision is missing, it is taken as 6; if the precision is zero, no decimal-point character appears. An E conversion uses the letter E (rather than e) to introduce the exponent.
f,F The double argument is rounded and converted to decimal notation in the style [-]ddd.ddd.
c An unsigned char.
s A pointer to an array of character type (pointer to a string). The array must contain a terminating null.
p The void * pointer argument is printed in hexadecimal (as if by %#x or %#lx).
% A ‘%’ is written. No argument is converted. The complete conversion specification is ‘%%’.

Examples

printf("%c \n", 'a');
a

printf("%d \n", 100);
100

printf("%ld \n", 5000000000);
5000000000

printf("%06d \n", 100);
000100

printf("%6d \n", 100);
   100

printf("%s \n", "14 char string");
14 char string

printf("%.10s \n", "14 char string");
14 char st

char * ptr = "string";
printf("%p \n", ptr);
0x400788

printf("%X \n", 100);
64

printf("%#X \n", 100);
0X64

printf("%o \n", 100);
144

printf("%#o \n", 100);
0144

printf("%#x \n", 100);
0x64

printf("%f \n", 3.14159);
3.141590

printf("%e \n", 3.14159);
3.141590e+00

printf("%E \n", 3.14159);
3.141590E+00

printf("%6d %d \n", 100, 100);
   100 100

printf("%-6d %d \n", 100, 100);
100    100

The entire family of printf functions including fprintf, sprintf, snprintf, vprintf, vfprintf, vsprintf, and vsnprintf take advantage of these formatting rules as well. In addition, many other languages have printf implementations which operate in much the same way.