← Back to branch summary

~jamesodhunt/upstart/async-spawn.20140310

« back to all changes in this revision

Viewing changes to test/test_util_common.c

  • Committer: James Hunt
  • Date: 2014-03-10 15:13:52 UTC
  • Revision ID: james.hunt@ubuntu.com-20140310151352-06mj0njwsgvi0fa0
temporary commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test_util_common.c
28
28
#include <nih/string.h>
29
29
#include <nih/signal.h>
30
30
#include <nih/logging.h>
 
31
#include <nih/timer.h>
 
32
#include <nih/io.h>
 
33
#include <nih/child.h>
 
34
#include <nih/main.h>
31
35
#include <nih-dbus/test_dbus.h>
32
36
 
33
37
#include <dbus/dbus.h>
74
78
static void selfpipe_setup (void);
75
79
 
76
80
/**
 
81
 * test_job_process_handler_pid:
 
82
 *
 
83
 * PID passed to test_job_process_handler().
 
84
 **/
 
85
pid_t test_job_process_handler_pid = -1;
 
86
 
 
87
/**
 
88
 * test_job_process_handler_event:
 
89
 *
 
90
 * event passed to test_job_process_handler().
 
91
 **/
 
92
NihChildEvents test_job_process_handler_event = 0x0;
 
93
 
 
94
/**
 
95
 * test_job_process_handler_status:
 
96
 *
 
97
 * status passed to test_job_process_handler().
 
98
 **/
 
99
int test_job_process_handler_status = -1;
 
100
 
 
101
/**
77
102
 * wait_for_upstart:
78
103
 *
79
104
 * @session_init_pid: pid of Session Init (which uses a private bus
1002
1027
 
1003
1028
        }
1004
1029
}
 
1030
 
 
1031
/**
 
1032
 * timer_cb:
 
1033
 *
 
1034
 * @data: unused,
 
1035
 * @timer: timer.
 
1036
 *
 
1037
 * Exit main loop with an error value indicating that the expected main
 
1038
 * loop events/actions were not performed within the expected time.
 
1039
 **/
 
1040
void
 
1041
timer_cb (void *data, NihTimer *timer)
 
1042
{
 
1043
        nih_assert (timer);
 
1044
 
 
1045
        /* Return non-zero to denote failure */
 
1046
        nih_main_loop_exit (1);
 
1047
}
 
1048
 
 
1049
/**
 
1050
 * test_job_process_handler:
 
1051
 *
 
1052
 * @data: unused,
 
1053
 * @pid: process that changed,
 
1054
 * @event: event that occurred on the child,
 
1055
 * @status: exit status, signal raised or ptrace event.
 
1056
 *
 
1057
 * Handler that just sets some globals and requests the main loop to
 
1058
 * exit to allow the test that installs it to check the values passed to
 
1059
 * this function as appropriate.
 
1060
 **/
 
1061
void
 
1062
test_job_process_handler (void           *data,
 
1063
                          pid_t           pid,
 
1064
                          NihChildEvents  event,
 
1065
                          int             status)
 
1066
{
 
1067
        nih_assert (pid > 0);
 
1068
 
 
1069
        /* Check that TEST_RESET_MAIN_LOOP() has been called */
 
1070
        nih_assert (test_job_process_handler_pid == -1);
 
1071
 
 
1072
        test_job_process_handler_pid = pid;
 
1073
        test_job_process_handler_event = event;
 
1074
        test_job_process_handler_status = status;
 
1075
 
 
1076
        /* FIXME */
 
1077
#if 0
 
1078
        printf ("XXX:%s:%d:pid=%d, event=%x, status=%x\n",
 
1079
                        __func__, __LINE__,
 
1080
                        pid, event, status);
 
1081
        fflush (NULL);
 
1082
#endif
 
1083
 
 
1084
        nih_main_loop_exit (0);
 
1085
}
 
1086
 
 
1087
/**
 
1088
 * fd_valid:
 
1089
 * @fd: file descriptor.
 
1090
 *
 
1091
 * Return 1 if @fd is valid, else 0.
 
1092
 **/
 
1093
int
 
1094
fd_valid (int fd)
 
1095
{
 
1096
        int flags = 0;
 
1097
 
 
1098
        if (fd < 0)
 
1099
                return 0;
 
1100
 
 
1101
        errno = 0;
 
1102
        flags = fcntl (fd, F_GETFL);
 
1103
 
 
1104
        if (flags < 0)
 
1105
                return 0;
 
1106
 
 
1107
        /* redundant really */
 
1108
        if (errno == EBADF)
 
1109
                return 0;
 
1110
 
 
1111
        return 1;
 
1112
}
 
1113
 
 
1114
/**
 
1115
 * read_from_fd:
 
1116
 *
 
1117
 * @parent: parent,
 
1118
 * @fd: open file descriptor.
 
1119
 *
 
1120
 * Read from the specified fd, close the fd and return the data.
 
1121
 *
 
1122
 * Returns: Newly-allocated NihIoBuffer representing data read from @fd.
 
1123
 *
 
1124
 **/
 
1125
NihIoBuffer *
 
1126
read_from_fd (void *parent, int fd)
 
1127
{
 
1128
        NihIoBuffer *buffer = NULL;
 
1129
        ssize_t      len;
 
1130
 
 
1131
        assert (fd >= 0);
 
1132
 
 
1133
        buffer = nih_io_buffer_new (parent);
 
1134
        nih_assert (buffer);
 
1135
 
 
1136
        while (TRUE) {
 
1137
 
 
1138
                nih_assert (! nih_io_buffer_resize (buffer, 1024));
 
1139
 
 
1140
                len = read (fd,
 
1141
                                buffer->buf + buffer->len,
 
1142
                                buffer->size - buffer->len);
 
1143
 
 
1144
                if (len <= 0)
 
1145
                        break;
 
1146
                else if (len > 0)
 
1147
                        buffer->len += len;
 
1148
        }
 
1149
 
 
1150
        close (fd);
 
1151
 
 
1152
        return buffer;
 
1153
}