HyperTerminal Private Edition 7.0
HyperTerminal Private Edition is a terminal emulation program. Download now
Size: 3.20MB License: Shareware Price: $59.99 By: Hilgraeve, Inc

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <netdb.h>

#include <proto/exec.h>
#include <proto/bsdsocket.h>

#define MAX_BUF 100

int main(int argc, char* argv[])
{
int sockd;
int count;
struct sockaddr_in serv_name;
char buf[MAX_BUF];
int status;

/* create a socket */
sockd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockd == -1)
{
perror("Socket creation");
exit(1);
}

/* server address */
serv_name.sin_family = AF_INET;
struct hostent *hent = gethostbyname("www.google.com");
if (!hent)
{
perror ("gethostbyname failed");
exit(-1);
}
if (hent->h_addrtype != AF_INET)
{
perror("Unknown address type");
exit(-1);
}

printf("hostname = %s\n", hent->h_name);

//What is supposed to happen here???
//serv_name.sin_addr.s_addr = inet_addr(hent->h_addr_list[0]);
memcpy (&(serv_name.sin_addr.s_addr), hent->h_addr, hent->h_length);
serv_name.sin_port = htons (12345);

/* connect to the server */
status = connect(sockd, (struct sockaddr*)&serv_name, sizeof(serv_name));
if (status == -1)
{
perror("Connection error");
exit(1);
}
printf("connected to server\n");

BYTE socketSignal = IExec->AllocSignal(-1);
uint32 socketSignalMask = 1 << socketSignal;

printf("socketSignalMask = 0x%x\n", socketSignalMask);

ISocket->SocketBaseTags (SBTM_SETVAL(SBTC_SIGEVENTMASK), socketSignalMask, TAG_END);

ULONG temp = FD_ACCEPT | FD_CONNECT | FD_READ | FD_WRITE | FD_ERROR;
setsockopt(sockd, SOL_SOCKET, SO_EVENTMASK, &temp, sizeof(temp));

IExec->Wait (socketSignalMask|SIGBREAKF_CTRL_C);
printf("signal received\n");

count = read(sockd, buf, MAX_BUF);
write(1, buf, count);

close(sockd);

IExec->FreeSignal(socketSignal);
return 0;
}

setsockopt(sockets[0], SOL_SOCKET, SO_EVENTMASK, (const void *)&socketSignalMask, sizeof(socketSignalMask));

#define DATA1 "test string 1"
#define DATA2 "test string 2"

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <errno.h>
#include <fcntl.h>

#include <proto/exec.h>
#include <proto/bsdsocket.h>

/*
* set_nonblocking(): Set a fd into nonblocking mode.
*/
static int set_nonblocking(int fd)
{
int val;

if((val = fcntl(fd, F_GETFL, 0)) == -1) return -1;
if (!(val & O_NONBLOCK)) {
val |= O_NONBLOCK;
fcntl(fd, F_SETFL, val);
}
return 0;
}

/*
* set_blocking(): Set a fd into blocking mode.
*/
static int set_blocking(int fd)
{
int val;

if((val = fcntl(fd, F_GETFL, 0)) == -1) return -1;
if (val & O_NONBLOCK) {
val &= ~O_NONBLOCK;
fcntl(fd, F_SETFL, val);
}
return 0;
}

/*
* __socketpair_tcp(): Create a socket pipe.
*/
int __socketpair_tcp(int fd[2])
{
int listener;
struct sockaddr sock;
socklen_t socklen = sizeof(sock);
int len = socklen;
int one = 1;
int connect_done = 0;

fd[0] = fd[1] = listener = -1;

memset(&sock, 0, sizeof(sock));

if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
goto failed;
}

setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));

if (listen(listener, 1) != 0) {
goto failed;
}

if (getsockname(listener, &sock, (socklen_t *) &socklen) != 0) {
goto failed;
}

if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) {
goto failed;
}

setsockopt(fd[1], SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));

set_nonblocking(fd[1]);

if (connect(fd[1], (struct sockaddr *) &sock, sizeof(sock)) == -1) {
if (errno != EINPROGRESS) {
goto failed;
}
connect_done = 1;
} else {
connect_done = 1;
}

if ((fd[0] = accept(listener, &sock, (socklen_t *) &len)) == -1) {
goto failed;
}

setsockopt(fd[0], SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof(one));

close(listener); listener = -1;
if (connect_done == 0) {
if (connect(fd[1], (struct sockaddr *) &sock, sizeof(sock)) != 0) {
goto failed;
}
}

set_blocking(fd[1]);

/* all OK! */
return 0;

failed:
printf("socketpair failed!\n");
if (fd[0] != -1) close(fd[0]);
if (fd[1] != -1) close(fd[1]);
if (listener != -1) close(listener);
return -1;
}

main()
{
int sockets[2], child;
char buf[1024];

/* Get the socket pair */
if (__socketpair_tcp(sockets) < 0) {
printf("error %d on socketpair\n", errno);
exit(1);
}
BYTE socketSignal = IExec->AllocSignal(-1);
uint32 socketSignalMask = 1 << socketSignal;

printf("socketSignalMask = 0x%x\n", socketSignalMask);

ISocket->SocketBaseTags (SBTM_SETVAL(SBTC_SIGEVENTMASK), socketSignalMask, TAG_END);

/* write message to child */
if (write(sockets[1], DATA1, sizeof(DATA1)) < 0) {
printf("error %d writing socket\n", errno);
exit(1);
}

/* send message to parent */
if (write(sockets[0], DATA2, sizeof(DATA1)) < 0) {
printf("error %d writing socket\n", errno);
exit(1);
}

IExec->Wait(socketSignalMask);

/* get message from parent */
if (read(sockets[0], buf, sizeof(buf)) < 0) {
printf("error %d reading socket\n", errno);
exit(1);
}
printf("-->%s\n", buf);

IExec->FreeSignal (socketSignal);

/* finished */
close(sockets[0]);
close(sockets[1]);
}

Btw, did QtOpenGL module works in AmyCygnix setup ?

Maybe still some help except testing we can do ?

#include <proto/exec.h>
#include <devices/timer.h>
#include <stdio.h>

int main (int argc, char **argv)
{
//open timer.device
struct MsgPort *timerPort = IExec->CreatePort (NULL, 0L);
uint32 timerSignalMask = (1 << timerPort->mp_SigBit);
struct TimeRequest *timerRequest = (struct TimeRequest *) IExec->CreateIORequest (timerPort, sizeof (struct TimeRequest));

IExec->OpenDevice (TIMERNAME, UNIT_MICROHZ, (struct IORequest *)timerRequest, 0L);

//set timeval and start IO
timerRequest->Time.Seconds = 10;
timerRequest->Time.Microseconds = 0;
IExec->SendIO ((struct IORequest *)timerRequest);

//await result
IExec->WaitPort (timerPort);
printf("timeout!\n");

//close timer.device
IExec->CloseDevice ((struct IORequest *)timerRequest);
IExec->DeleteIORequest ((struct IORequest *)timerRequest);
IExec->DeletePort (timerPort);

return (0);
}

(can you imagine going at the QT Developer Day showing off an Amiga?!?!?!?)

Is there anything in 4.7 that makes its port easier than 4.6.2?