.include "DS.S"

#-----------------------------------------------

#	S T A T I C   V A R I A B L E S

#-----------------------------------------------

	.data

	.global C.csP

C.csP:	.int	0				# -->CS

	.text

#-----------------------------------------------

#	M A I N   R O U T I N E

#-----------------------------------------------

# takes values from ENV, establishes task for comm nodes and waits for their completion

	ARGS

	DS	prgP				# -->progname

# returns	nothing

	PROLOC

	DL	this, CSL			# CS - top level attr vector

	DL	deP				# -->Debug

	DL	status				# status returned from wait

	DL	pid				# PID returned from wait

	DL	bad				# cummulative subtask rc

	DL	s, 256				# string buf

	EPILOC

#-----------------------------------------------

	.global _start

_start:

	PROLOG

	lea	this(bp), b			# -->CS

	mov	b, C.csP			# save -->CS

	lea	C.debug(b), a			# -->Debug

	mov	a, deP(bp)

# initialize static debug vars

	push	prgP(bp)			# argv[0] -->prgname

	call	D.init				# initialize static debug vars

	push	D.prgNameP

# indetify itself

	DEBID	"client/server demo"

	movl	$1, C.debMaxLev(b)		# default debug level

# initialize top level ctrl values vector

	ShareA					# allocate shared structure

	mov	C.csP, b

	mov	a, C.shP(b)			# save -->shared struct in vector

	movl	$0, S.msgs(a)			# init msg cntr

	movl	$0, S.conns(a)			# init connection cntr

	push	$1				# initial semaphore value

	push	$1				# semaphore shared between processes

	lea	S.counter_sem(a), c

	push	c

#	call	sem_init			# initialize shared counters semaphore

#	cmp	$0, a

#	jz	0f

#	SYSERR	"sem_init of shared counters semaphore"

#0:

	SYS	sem_init

# set default values

	mov	C.csP, b

	movl	$3, C.ttl(b)			# default TTL

	movl	$11000, C.rp0(b)		# default bind port for the 1. node in ring

	movl	$12000, C.mp0(b)		# default bind port for the 1. node in mash

	movl	$0, C.rn(b)			# default # of nodes in ring

	movl	$0, C.mn(b)			# default # of nodes in mash

	movl	$0, C.ssl(b)			# default ssl switch - 0=noSSL

	movl	$77, C.connTh(b)		# conn retries threshold

	mov	$0f, a

	mov	a, C.txtP(b)			# default payload text

	jmp	1f

0:	.ascii "bla bla\0"

1:

# get control values from ENV

# get max debug level

	GETINTENV "DEB"

	mov	C.csP, b

	mov	a, C.debMaxLev(b)

	cmp	$-1, a				# debug level -1 means search subroutines

	jne	0f

	call	D.subr

	jmp	C.ret

0:

# get message payload text

	push	$0f

	call	getenv

	cmp	$0, a

	jz	1f

	mov	C.csP, b

	mov	a, C.txtP(b)

	jmp	1f

0:	.asciz "T"

1:

# get TTL

	GETINTENV "TTL"

	jz	0f

	mov	a, C.ttl(b)

0:

# get # of nodes in each topology

	GETINTENV "I"

	jz	0f

	mov	a, C.rn(b)

	mov	a, C.mn(b)

0:

# get # of nodes in ring

	GETINTENV "RN"

	jz	0f

	mov	a, C.rn(b)

0:

# get # of nodes in mash

	GETINTENV "MN"

	jz	0f

	mov	a, C.mn(b)

0:

	add	C.rn(b), a

	cmp	$3, C.ssl(b)

	jne	1f

	add	a, a				# double # of nodes when both SSL and nonSSL

1:	mov	C.shP(b), c			# -->shared counters

	mov	a, S.act(c)			# save # of active nodes

# get first ring node's bind port#

	GETINTENV "RP0"

	jz	0f

	mov	a, C.rp0(b)

0:

# get first mash node's bind port#

	GETINTENV "MP0"

	jz	0f

	mov	a, C.mp0(b)

0:

# get random() seed

	GETINTENV "RS"

	jz	0f

	push	a

	call	srandom

0:

# get pacing interval (real num in seconds)

	movl	$0, C.pace.tv_sec(b)

	movl	$0, C.pace.tv_nsec(b)

	movl	$0, C.pacing(b)

	push	$0f

	call	getenv

	jmp	1f

0:	.asciz "P"

1:

	test	a, a				# env P set ?

	jz	3f				# no

	push	a

	call	atof				# convert to double

	fstl	(sp)				# tempor save

	mov	C.csP, b

	fisttpl	C.pace.tv_sec(b)		# truncated integral part = secs

	fldl	(sp)

	fisubl	C.pace.tv_sec(b)		# fraction part

	fimull	1f				# * 10^9 = nanosecs

	fistl	C.pace.tv_nsec(b)

	jmp	2f

0:	.double	0

1:	.int	1000000000			# 10^9

2:

	cmp	$0, C.pace.tv_sec(b)

	jnz	0f

	cmp	$0, C.pace.tv_nsec(b)

	jz	3f

0:	movl	$1, C.pacing(b)

3:

# get ssl switch value and save it as mask

# switch: 0 = noSSL, 1 = SSL, 2 = both

# mask: 01B=noSSL, 10B=SSL, 11B=both

	GETINTENV "SSL"				# returned zero means SSL=0 or SSL by default 0

	inc	a				# change switch to mask

	mov	a, C.ssl(b)

	cmp	$1, a

	je	C.cont				# no SSL

	cmp	$2, a

	je	0f				# only SSL

	mov	C.shP(b), a			# -->shared mem

	shll	$1, S.act(a)			# double # of active nodes when running both SSL and nonSSL

# get SSL CA cert dir path

0:

	push	$0f

	call	getenv

	jmp	1f

0:	.asciz "CAP"

1:

	test	a, a

	jnz	1f

	mov	$0f, a

	jmp	1f

0:	.asciz	"/home/local/etc/ssl/certs/"

1:

	mov	C.csP, b

	mov	a, C.caPathP(b)			# save -->SSL CA certs path

# get SSL dir path

	push	$0f

	call	getenv

	jmp	1f

0:	.asciz "CEP"

1:

	test	a, a

	jz	0f				# ceP not set, try to determine

	mov	C.csP, b

	mov	a, C.cePathP(b)			# save -->SSL dir path

	jmp	1f

# determine home path (needed to locate SSL keys & certificates)

0:

	push	prgP(bp)			# -->first parm - progname w/ path

	call	dirname				# get prog dirname

	push	a

	call	strlen				# dirname length

	lea	1f-0f(a), a			# + suffix length

	sub	a, sp				# allocate space for cePath

	mov	C.csP, b

	mov	sp, C.cePathP(b)		# save -->SSL path

	push	prgP(bp)

	call	dirname				# get home dirname

	push	a				# -->home dirname

	mov	C.csP, b

	push	C.cePathP(b)			# -->SSL path

	call	strcpy				# copy dirname to SSL path

	call	strlen				# end of dirname

	push	$0f				# -->suffix

	mov	C.csP, b

	mov	C.cePathP(b), c

	lea	(c, a), a			# -->end of dirname

	push	a

	call	strcpy				# copy suffix to SSL path

	jmp	1f

0:	.asciz	"/../CS/"

1:

# testing sandbox

	mov	C.csP, b

	pushl	C.debMaxLev(b)

	cmp	$9, C.debMaxLev(b)

	jne	C.cont

	LOG	9, "debug=%u, testing...", 1

	DebugA

	mov	a, deP(bp)

	DEBID	"TEST"

	LOG	9, "progress"

	mov	C.csP, b

	mov	C.shP(b), a

	push	S.act(a)

	LOG	9, "shared act=%u"

	jmp	C.ret

# normal execution

C.cont:

	push	C.debMaxLev(b)

	push	C.ssl(b)

	push	C.pace.tv_nsec(b)

	push	C.pace.tv_sec(b)

	push	C.ttl(b)

	push	C.rn(b)

	push	C.mn(b)

	push	D.prgNameP

	LOG	1, "pgm=%s, mash nodes=%d, ring nodes=%d, ttl=%d, pacing=%ld.%09ld, SSL mask=0x%02x, debug=%u", 8

	testl	$2, C.ssl(b)

	jz	0f

	push	C.caPathP(b)

	push	C.cePathP(b)

	LOG	1, "SSL path=%s, SSL CA path=%s"

0:

# create constellation processes RING/MASH, nonSSL/SSL

	mov	$0, c				# iter counter

	mov	C.ssl(b), d			# SSL mask (01b = noSSL, 10b = SSL, 11b = both)

# iterate on SSL variants

C.iterateOnSsl:

	test	$1, d				# check lowest bit of mask

	jz	C.nextSsslVar			# next SSL variant

	pusha

# create RING

	SYS	fork

	jnz	1f				# parent

	popa

	pushl	$Cn.ring			# RING topology

	push	c				# use iter ctr as SSL switch

	call	Constellation			# create RING constellation

1:	push	a

	LOG	5, "RING started in process %d"

	lea 	4(sp), sp

# create MASH

	SYS	fork

	jnz	1f				# parent

	popa

	pushl	$Cn.mash			# MASH topology

	push	c				# use iter ctr as SSL switch

	call	Constellation			# create MASH constellation

1:	push	a

	LOG	5, "MASH started in process %d"

	lea 	4(sp), sp

	popa

C.nextSsslVar:

	shr	$1, d				# shift to test next SSL bit

	inc	c				# incr ctr

	cmp	$2, c

	jl	C.iterateOnSsl

# wait for constellation processes completion

	LOG	5, "waiting for constellations to terminate"

	movl	$0, bad(bp)			# clear cummulative rc

C.iterateOnWait:

	lea	status(bp), a

	push	a				# -->return status of task

	call	wait

	mov	a, pid(bp)			# save pid

	cmp	$-1, a				# a task ended?

	jne	0f				# yes

	call	__errno_location

	cmp	$10, (a)			# error == ECHILD ?

	je	C.ret				# yes, no other subtasks

	SYSERR	"wait"

0:

#	push	status(bp)			# status of task

#	push	a				# pid

#	LOG	5, "status returned from task %u: 0x%08x"

	mov	status(bp), d

	test	$0x7f, d

	jnz	1f				# task killed, ABEND

	and	$0xff00, d			# task exited, extract rc

	shr	$8, d

	or	d, bad(bp)			# accumulate rc

	push	d				# task rc

	push	pid(bp)				# task pid

	LOG	5, "constellation task %u ended with exit(%d)"

	jmp	C.iterateOnWait			# wait for other tasks

1:	push	d

	push	pid(bp)

	LOG	5, "constellation task %u killed, status=0x%x", 2

2:

# ABEND

	LOG	0, "ABEND, kill all tasks"

	pushl	$15				# SIGTERM

	pushl	$0				# all tasks

#	call	kill

	SYS	kill

	pushl	$1

	call	exit

# normal end

C.ret:	movl	C.csP, b			# -->CS vector

	movl	C.shP(b), b			# -->Share

	pushl	S.conns(b)			# no. of connections made

	pushl	S.msgs(b)			# no. of messages sent

	LOG	1, "END, forwards=%d, connections=%d", 2

	push	bad(bp)

	call	exit

#-----------------------------------------------

#	 C O N S T E L L A T I O N   O P E R A T I O N S

#-----------------------------------------------

	ARGS

	DS	ssl				# ssl switch

	DS	topo				# topology

# returns:	nothing

	PROLOC

	DL	this, ConstellationL		# this Constellation instance

	DL	thisP				# -->this Constellation

	DL	deP				# -->Debug

	DL	last				# last node#

	DL	pid				# pid returned from wait

	DL	stat				# stat returned from wait

	DL	bad				# "some node BAD" exit indicator

	DL	catched				# count of returned node tasks

	DL	killed				# count of killed node tasks

	EPILOC

#-----------------------------------------------

	.global Constellation

Constellation:

	PROLOG

	lea	this(bp), b			# -->this Constellation

	mov	b, thisP(bp)			# save -->this Constellation

# set debid

	lea	Cn.debug(b), a			# -->Debug

	mov	a, deP(bp)			# save -->Debug locally

	mov	C.csP, c			# -->CS

	cmp	$Cn.ring, topo(bp)		# ring topology ?

	je	0f

	mov	C.mn(c), a			# num. of nodes

	mov	a, Cn.nodes(b)

	mov	C.mp0(c), a			# port # of fist node

	mov	a, Cn.first(b)

	movl	$Cn.mash, Cn.topo(b)

	push	$8f

	jmp	1f

0:	mov	C.rn(c), a			# num. of nodes

	mov	a, Cn.nodes(b)

	mov	C.rp0(c), a			# port # of fist node

	mov	a, Cn.first(b)

	movl	$Cn.ring, Cn.topo(b)

	push	$7f

1:	cmp	$0, ssl(bp)			# SSL ?

	jz	2f				# no

	movl	$1, Cn.ssl(b)

	addl	$500, Cn.first(b)		# first SSL port #

	push	$6f

	jmp	9f

2:	movl	$0, Cn.ssl(b)

	push	$5f

	jmp	9f

5:	.ascii	"non\0"

6:	.ascii	"\0"

7:	.ascii	"RING\0"

8:	.ascii	"MASH\0"

9:	DEBID	"%sSSL %s", 2

# check # of nodes

	movL	$0, bad(bp)

	cmp	$1, Cn.nodes(b)			# num of nodes

	jl	Cn.ret			# < 1 ? nothing to do

	jg	0f

	LOG	0, "1 node configuration not implemented yet"

	jmp	Cn.ret

0:	LOG	5, "initializing..."

# determine divisor for random next node choise

	mov     $1, a

        shl     $31, a

        not     a             			# MAX_INT

        xor     d, d

        divl    Cn.nodes(b)

        mov     a, Cn.div(b)			# save divisor (MAX_INT / nodes)

# allocate "forward" indicator shared by nodes in constellation

	push	$0

	push	$-1

	push	$0x21				# PROT_READ | PROT_WRITE

	push	$0x03				# MAP_SHARED | MAP_ANONYMOUS

	push	$4

	push	$0

#	call	mmap

#	cmp	$-1, a

#	jne	0f

#	SYSERR	"mmap"

#0:	mov	thisP(bp), b

	SYS	mmap

	mov	a, Cn.forwP(b)			# save -->forw

	movl	$1, (a)				# enable forwarding

	push	Cn.nodes(b)

	LOG	1, "%u nodes starting..."

# start processes for all nodes in constellation

	mov	Cn.first(b), d			# first node#

	mov	d, c

	add	Cn.nodes(b), c			# last node + 1

Cn.iterateOnFork:

	pusha

#	call	fork

	SYS	fork

	cmp	$0, a

	jnz	1f				# parent

	popa

	push	d				# node's port#

	push	b				# -->Cnstlln

	call	Node

1:	mov	a, pid(bp)

	popa

	push	pid(bp)				# nodes's pid

	push	d				# node's port#

	LOG	4, "node %u established in process %u", 2

	inc	d

	cmp	d, c				# last node ?

	jg	Cn.iterateOnFork		# no, continue forking

# wait for completion of node processes

	LOG	2, "all nodes established, waiting for them to terminate..."

	movl	$0, bad(bp)			# accumulated return status of node tasks

	movl	$0, killed(bp)			# num. of killed node tasks

	movl	$0, catched(bp)			# num. of returned node tasks

	lea	-12(sp), sp			# prepare space for loop

Cn.iterateOnWait:

	cmp	$0, bad(bp)			# constellation status still OK ?

	je	1f				# yes

	mov	Cn.forwP(b), a			# -->forwarding switch

	movl	$0, (a)				# disable forwarding between nodes

1:

	lea	stat(bp), c

	mov	c, (sp)				# -->return status of task

	call	wait

	mov	thisP(bp), b

	cmp	$-1, a				# normal return from wait?

	jne	0f				# yes

	call	__errno_location

	cmp	$10, (a)			# error == ECHILD ?

	je	Cn.allFinished			# yes, no subtasks

	SYSERR	"wait"

0:

	incl	catched(bp)

	mov	a, pid(bp)			# save subtask's pid

	mov	a, (sp)

	mov	stat(bp), c			# subtask return status

	mov	c, 4(sp)

	test	$0x7f, c			# subtask ended by exit ?

	jnz	2f				# no, killed

	and	$0xff00, c			# extract subtask rc

	jz	1f				# rc = 0

	movl	$1, bad(bp)			# non zero rc, turn on BAD switch

1:	shr	$8, c

	mov	c, 4(sp)			# rc

	mov	a, (sp)				# pid

	LOG	4, "node process %u ended by exit(%d)"

	jmp	Cn.iterateOnWait		# continue waiting for other subtasks

2:	movl	$1, bad(bp)			# subtask killed, turn on BAD switch

	incl	killed(bp)			# counter of killed

	mov	c, 4(sp)			# status

	mov	a, (sp)				# pid

	LOG	4, "node process %u killed, status=0x%x"

	jmp	Cn.iterateOnWait		# continue waiting for other subtasks

# opers of all nodes finished

Cn.allFinished:

	push	killed(bp)

	push	catched(bp)

	mov	thisP(bp), b

	push	Cn.nodes(b)

	cmp	$0, bad(bp)			# all nodes ended OK ?

	je	0f				# yes

	push	$7f

	jmp	9f

0:	push	$8f

	jmp	9f

7:	.ascii	"with ERROR\0"

8:	.ascii	"OK\0"

9:	LOG	1, "ENDED %s, %u spawned, %u catched, %u killed"

Cn.ret:

	push	bad(bp)

	call	exit

#-----------------------------------------------

#	G E T   I N T   V A L U E S   F R O M   E N V

#-----------------------------------------------

	ARGS

	DS	key				# -->env key string

# returns	int value or 0 if not found

	PROLOC

	EPILOC

#-----------------------------------------------

C.getArg:

	PROLOG

	pushl	key(bp)				# -->env key string