ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH: 0

ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH: 0

# On Fedora, libcap package provides getpcaps command.

ts_check_prog "getpcaps"

return 0

fi

fputs(" -I, --parameters <factory> list parameters the factory takes\n", out);

fputs(" -r, --comm <name> rename self\n", out);

fputs(" -q, --quiet don't print pid(s)\n", out);

fputs(" -c, --dont-pause don't pause after making fd(s)\n", out);

fputs("\n", out);

}

#endif

{

fd_set readfds;

sigset_t sigset;

int n = 0;

FD_ZERO(&readfds);

n = 1;

FD_SET(0, &readfds);

}

bool quiet = false;

bool cont = false;

void *data;

static const struct option longopts[] = {

{ "list", no_argument, NULL, 'l' },

{ "parameters", required_argument, NULL, 'I' },

{ "comm", required_argument, NULL, 'r' },

{ "quiet", no_argument, NULL, 'q' },

{ "dont-puase", no_argument, NULL, 'c' },

{ "help", no_argument, NULL, 'h' },

{ NULL, 0, NULL, 0 },

};

switch (c) {

case 'h':

usage(stdout, EXIT_SUCCESS);

case 'r':

rename_self(optarg);

break;

default:

usage(stderr, EXIT_FAILURE);

}

}

if (!cont)

for (int i = 0; i < factory->N + factory->EX_N; i++)

if (fdescs[i].fd >= 0 && fdescs[i].close)

${TS_CMD_LSFD} -n -o ASSOC,STTYPE,AINODECLASS -p "${PID}" -Q "${EXPR}"

echo "$C"':ASSOC,STTYPE,AINODECLASS': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

EXPR='(FD == '"$FD"')'

${TS_CMD_LSFD} -p "$PID" -n -o DELETED -Q "${EXPR}"

echo "$C: DELETED: " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

EXPR='(FD == '"$FD"')'

${TS_CMD_LSFD} -p "$PID" -n -o DELETED -Q "${EXPR}"

echo "$C: DELETED: " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

}

echo "$C"':ASSOC,KNAME,NAME': ${PIPESTATUS[0]}

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

sed -e 's#.*/\([^/]\+\)#\1#'

echo "$C: DELETED,NAME: " ${PIPESTATUS[0]}

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -u ${MKFDS[0]} PID; then

${TS_CMD_LSFD} -p "$PID" -n -o ASSOC,SOURCE -Q "${EXPR}"

echo 'ASSOC,SOURCE': $?

fi

wait ${MKFDS_PID}

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -n -o ASSOC,STTYPE,TYPE -p "${PID}" -Q "${EXPR}"

echo "$C"':ASSOC,STTYPE,TYPE': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o MODE -p "${PID}" -Q "${EXPR}"

echo "MODE(r-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(r-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o MODE -p "${PID}" -Q "${EXPR}"

echo "MODE(w-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(w-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o MODE -p "${PID}" -Q "${EXPR}"

echo "MODE(x-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(x-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

ts_finalize_subtest

fi

EXPR='(FD == '"$FD"')'

ts_init_subtest "XMODE-D-bit"

{

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(D-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

for m in flock-sh posix-r- ofd-r-; do

ts_init_subtest "XMODE-l-bit-$m"

{

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(l-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(l-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

for m in flock-ex posix--w posix-rw ofd--w ofd-rw lease-w; do

ts_init_subtest "XMODE-L-bit-$m"

{

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(L-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

if read -r -u "${MKFDS[0]}" PID; then

"${TS_CMD_LSFD}" -n -o XMODE -p "${PID}" -Q "${EXPR}"

echo "XMODE(m-bit): " $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

PID_1=$((PID -1))

EXPR="(PID > ${PID_1}.9) and (PID < ${PID}.1) and (ASSOC == 'exe')"

echo "pid in a range:" $?

EXPR='(TIMERFD.INTERVAL < 10.000051) and (TIMERFD.INTERVAL > 10)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL <= 10) and (TIMERFD.INTERVAL > 9.99)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL >= 10)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL >= 10.0)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL < 10) and (0 < TIMERFD.INTERVAL)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL < 10) and (0.0 < TIMERFD.INTERVAL)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL > 11)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL == 10.00005)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

EXPR='(TIMERFD.INTERVAL == 10.000051)'

echo "FD,TIMERFD.INTERVAL: $EXPR": $?

fi

wait "${MKFDS_PID}"

"${TS_CMD_LSFD}" -r -n -oBPF-PROG.TYPE,BPF-PROG.TYPE.RAW -p "${PID}" -Q "(FD == $FD)"

echo "BPF-PROG.TYPE,BPF-PROG.TYPE.RAW": $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

echo "output TUN.IFACE: $output"

fi

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

echo 'stat reports:' "$(stat -c %h /)"

fi

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

echo 'lsfd:' "$tmp"

fi

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

echo 'ASSOC,TYPE,NAME,EVENTPOLL.TFDS': $?

${TS_CMD_LSFD} -J -p "${PID}" -n -o ASSOC,TYPE,NAME,EVENTPOLL.TFDS -Q "${EXPR}"

echo 'ASSOC,TYPE,NAME,EVENTPOLL.TFDS (JSON)': $?

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

echo "INOTIFY.INODES.RAW": "$INODES_RAW_JSON"

fi

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -p "$PID" -n -o NAME,SOCK.TYPE,SOCK.PROTONAME,PACKET.IFACE,PACKET.PROTOCOL -Q "${EXPR}"

echo 'NAME,SOCK.TYPE,SOCK.PROTONAME,PACKET.IFACE,PACKET.PROTOCOL': $?

fi

wait ${MKFDS_PID}

ERR=$?

echo 'lsfd:' "$tmp"

fi

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

else

printf "LPORT: FAILED (PID: %d != NETLINK.LPORT: %d)\n" "${PID}" "${NETLINK_LPORT}"

fi

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

else

printf "LPORT: FAILED (PID: %d != NETLINK.LPORT: %d)\n" "${PID}" "${NETLINK_LPORT}"

fi

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

echo "NAME_FD: $NAME_FD" == "net:[INO_NS: $INO_NS]": $?

fi

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -n -o ASSOC,STTYPE,SOURCE,NAME,PIDFD.COMM,PIDFD.PID -p "${PID}" -p ${TARGET} -Q "${EXPR}"

echo 'ASSOC,STTYPE,SOURCE,NAME,PIDFD.COMM,PIDFD.PID': $?

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

-o ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,${COLNS[$i]}.LADDR,${COLNS[$i]}.RADDR,PING.ID \

-p "${PID}" -Q "${EXPR[$i]}"

echo "ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,${COLNS[$i]}.LADDR,${COLNS[$i]}.RADDR,PING.ID": $?

fi

wait "${MKFDS_PID}"

-o ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,${COLNS[$i]}.LADDR,${COLNS[$i]}.RADDR,PING.ID \

-p "${PID}" -Q "${EXPR[$i]}"

echo "ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,${COLNS[$i]}.LADDR,${COLNS[$i]}.RADDR,PING.ID": $?

fi

} > "$TS_OUTPUT" 2>&1

wait "${MKFDS_PID}"

echo EXPECTED_LSFD_ENDPOINTS_JSON: "${EXPECTED_LSFD_ENDPOINTS_JSON}"

fi

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

-o ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,INET.LADDR,INET.RADDR,RAW.PROTOCOL \

-p "${PID}" -Q "${EXPR}"

echo 'ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,INET.LADDR,INET.RADDR,RAW.PROTOCOL': $?

fi

wait "${MKFDS_PID}"

-o ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,INET6.LADDR,INET6.RADDR,RAW.PROTOCOL \

-p "${PID}" -Q "${EXPR}"

echo 'ASSOC,TYPE,NAME,SOCK.STATE,SOCK.TYPE,INET6.LADDR,INET6.RADDR,RAW.PROTOCOL': $?

fi

wait "${MKFDS_PID}"

lsfd_compare_dev "${TS_CMD_LSFD}" "${LSFD_LOOP_BDEV}" "${EXPR}"

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

lsfd_compare_dev "${TS_CMD_LSFD}" $target "${EXPR}"

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

lsfd_compare_dev "${TS_CMD_LSFD}" $target "${EXPR}"

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

${TS_CMD_LSFD} -p "${PID}" -n -o "${COL}" -Q "${EXPR}"

echo "${COL}": $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -n -o ASSOC,MODE,STTYPE,SOURCE,SOCK.PROTONAME -Q "${EXPR}" | sed -e 's/UNIX-DGRAM/UNIX/'

echo 'ASSOC,MODE,STTYPE,SOURCE,SOCK.PROTONAME': ${PIPESTATUS[0]}

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

${TS_CMD_LSFD} -n -o ASSOC,MODE,TYPE,NAME,FLAGS -Q "${EXPR}"

echo 'ASSOC,MODE,TYPE,NAME,FLAGS': $?

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

-p "${PID}" -Q "${EXPR}"

echo 'ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET.LADDR,INET.RADDR,TCP.LADDR,TCP.LPORT,TCP.RADDR,TCP.RPORT': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

-p "${PID}" -Q "${EXPR}"

echo 'ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET6.LADDR,INET6.RADDR,TCP.LADDR,TCP.LPORT,TCP.RADDR,TCP.RPORT': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -p "${PID}" -n -o TIMERFD.INTERVAL -Q "${EXPR}"

echo 'TIMERFD.INTERVAL': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -p "${PID}" -n -o TIMERFD.INTERVAL -Q "${EXPR}"

echo 'TIMERFD.INTERVAL': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -p "${PID}" -n -o TIMERFD.INTERVAL -Q "${EXPR}"

echo 'TIMERFD.INTERVAL': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

${TS_CMD_LSFD} -p "${PID}" -n -o TIMERFD.INTERVAL -Q "${EXPR}"

echo 'TIMERFD.INTERVAL': $?

fi

wait "${MKFDS_PID}"

done

-p "${PID}" -Q "${EXPR[$lite]}"

echo "ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET.LADDR,INET.RADDR,${COLNS[$lite]}.LADDR,${COLNS[$lite]}.LPORT,${COLNS[$lite]}.RADDR,${COLNS[$lite]}.RPORT": $?

fi

wait "${MKFDS_PID}"

echo "NAME pattern match: FAILED (NAME=$NAME)"

fi

fi

wait "${MKFDS_PID}"

echo "LADDR/LPORT pattern match: FAILED (LADDR=$LADDR, LPORT=$LPORT)"

fi

fi

wait "${MKFDS_PID}"

-p "${PID}" -Q "${EXPR[$lite]}"

echo 'ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET.LADDR,INET.RADDR,UDP.LADDR,UDP.LPORT,UDP.RADDR,UDP.RPORT': $?

fi

wait "${MKFDS_PID}"

done > "$TS_OUTPUT" 2>&1

-p "${PID}" -Q "${EXPR[$lite]}"

echo "ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET6.LADDR,INET6.RADDR,${COLNS[$lite]}.LADDR,${COLNS[$lite]}.LPORT,${COLNS[$lite]}.RADDR,${COLNS[$lite]}.RPORT": $?

fi

wait "${MKFDS_PID}"

echo "NAME pattern match: FAILED (NAME=$NAME)"

fi

fi

wait "${MKFDS_PID}"

echo "LADDR/LPORT pattern match: FAILED (LADDR=$LADDR, LPORT=$LPORT)"

fi

fi

wait "${MKFDS_PID}"

-p "${PID}" -Q "${EXPR[$lite]}"

echo "ASSOC,TYPE,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,INET6.LADDR,INET6.RADDR,${COLNS[$lite]}.LADDR,${COLNS[$lite]}.LPORT,${COLNS[$lite]}.RADDR,${COLNS[$lite]}.RPORT": $?

fi

wait "${MKFDS_PID}"

done > "$TS_OUTPUT" 2>&1

{

# The first one is for rewriting NAME column.

# The second one is for rewriting STATE column.

}

{

path=test_mkfds-unix-dgram ; }

if read -r -u "${MKFDS[0]}" PID; then

${TS_CMD_LSFD} -n \

-o ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH \

-p "${PID}" -Q "${EXPR}" | make_state_connected

echo 'ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

fi

wait "${MKFDS_PID}"

abstract=true ; }

if read -r -u "${MKFDS[0]}" PID; then

${TS_CMD_LSFD} -n \

-o ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH \

-p "${PID}" -Q "${EXPR}" | make_state_connected

echo 'ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': $?

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

compare_net_namespaces "$t" "${PID}"

fi

wait "${MKFDS_PID}"

compare_net_namespaces "abstract $t" "${PID}"

fi

wait "${MKFDS_PID}"

} > "$TS_OUTPUT" 2>&1

-p "${PID}" -Q "${EXPR}" | lsfd_strip_type_stream

echo 'ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

fi

wait "${MKFDS_PID}"

-p "${PID}" -Q "${EXPR}" | lsfd_strip_type_stream

echo '(abs) ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

fi

wait "${MKFDS_PID}"

echo '(shutdown) ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

# Surprisingly, the socket status doesn't change at all.

fi

wait "${MKFDS_PID}"

-p "${PID}" -Q "${EXPR}" | lsfd_strip_type_stream

echo 'ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

fi

wait "${MKFDS_PID}"

-p "${PID}" -Q "${EXPR}" | lsfd_strip_type_stream

echo 'ASSOC,STTYPE,NAME,SOCK.STATE,SOCK.TYPE,SOCK.LISTENING,UNIX.PATH': ${PIPESTATUS[0]}

fi

wait "${MKFDS_PID}"

ts_finalize "failed in creating a fifo"

fi

if ! read PID0 < "${FIFO}"; then

rm "${FIFO}"

ts_finalize "$TS_HELPER_MKFDS tcp...doesn't report its pid"

fi

if ! read PID1 < "${FIFO}"; then

kill -CONT "${PID0}"

wait "${PID0}"

ts_finalize "$TS_HELPER_MKFDS tcp6...doesn't report its pid"

fi

if ! read PID2 < "${FIFO}"; then

kill -CONT "${PID0}" "${PID1}"

wait "${PID0}" "${PID1}"

ts_finalize "$TS_HELPER_MKFDS ro-regular-file...doesn't report its pid"

fi

if ! read PID3 < "${FIFO}"; then

kill -CONT "${PID0}" "${PID1}" "${PID2}"

wait "${PID0}" "${PID1}" "${PID2}"

ts_finalize "$TS_HELPER_MKFDS udp...doesn't report its pid"

fi

if ! read PID4 < "${FIFO}"; then

kill -CONT "${PID0}" "${PID1}" "${PID2}" "${PID3}"

wait "${PID0}" "${PID1}" "${PID2}" "${PID3}"

[ "${QOUT}" = "${POUT}" ]

echo "EQ[-p PID --pid=1]:" $?

fi

wait ${MKFDS_PID}

} > $TS_OUTPUT 2>&1

PID=

for i in {1..10}; do

PID=$!

PIDS="${PIDS} ${PID} "

lsfd_wait_for_pausing "${PID}"

done

for i in {1..3}; do

PID=$!

PIDS="${PIDS} ${PID} "

lsfd_wait_for_pausing "${PID}"