This repository implements a collaborative Markdown editor comprised of three main layers:

1. Markdown Library - immutable editing core
2. Client - terminal-based user application
3. Server - multi-threaded coordinator, command queue, versioned broadcast

 document ├─ committed_head ─> [chunk] - committed content (read-only) ├─ head ─> [chunk] - WIP edits └─ del_ranges[] deferred deletions 

• Committed state - immutable snapshot of version N
• WIP state - edits for next version, lazily initialised

All public API functions follow the same pattern:

1. markdown_ensure_wip() - copy committed list on first edit
2. Adjust cursor using del_ranges helpers
3. Perform edit (insert, delete, heading …)
4. Consolidate text chunks to keep list compact

Return codes are SUCCESS / INVALID_CURSOR_POS / … defined in common.h.

• markdown_increment_version() commits the WIP list
• committed_version is incremented, WIP pointers reset
• markdown_flatten() always serialises the committed list → guarantees that only committed content is exposed to file/network.

markdown_horizontal_rule() inserts --- and lazily adds a trailing \n only when required, respecting block-element newline rules.

1. Signal handshake
   client sends SIGRTMIN → server
   waits for SIGRTMIN+1
2. FIFO pair
   FIFO_C2S_<pid> - write commands
   FIFO_S2C_<pid> - read broadcasts / replies
3. Authentication
   sends <username>\n, receives read / write or Reject UNAUTHORISED.
4. Document bootstrap
   reads role, version, length, then full content → loads into local_doc without incrementing version.

struct client { uint64_t current_version; // server version we believe in document *local_doc; // local committed copy ... };

• Main thread - CLI loop, sends commands, prints DOC?/LOG?/PERM?
• Broadcast thread - consumes FIFO_S2C, parses
  • read / write → signals PERM? response
  • VERSION N … END broadcast → process_broadcast_message()

1. Append every line to local log (linked list)
2. For each EDIT … SUCCESS line
   • call matching markdown_… using the document's current committed version
   • set edits_applied = true when edit succeeds
3. After END
   • if edits_applied - call markdown_increment_version() so DOC? sees the update
   • set local_doc->committed_version = target_version
   • set current_version = target_version

The client never invents a new version number - it adopts the server's.

All shared structures are protected by mutexes.

struct version_log_entry { uint64_t version_number; char *broadcast_message; // full multi-line VERSION … END block ... };

• add_log_entry() - append under mutex
• print_server_log() - dump to stdout on LOG? (admin)
• Used to replay history for new clients (LOG? from client).

• command_queue_push() - O(1) enqueue from client threads
• command_queue_drain() - main thread atomically grabs whole list each interval
• Commands carry client_doc_version to enforce version rules.

1. Creates FIFOs & sends role + initial document (version, length, content)
2. Reads commands line-by-line:
   • Metadata: PERM?, DOC?, LOG?, DISCONNECT
   • Edit commands pushed into command_queue
3. Read-only users are pre-labelled UNAUTHORISED before push.

while (!shutdown) { select(stdin, timeout = interval) → handle admin commands (QUIT / DOC? / LOG?) drain command_queue sort by timestamp for each cmd { version check & execute via Markdown API } if edits made → markdown_increment_version(global_doc) build broadcast "VERSION N\nEDIT …\nEND\n" add_log_entry() broadcast_to_all_clients() } 

• Interval Timing - sleeps via select timeout specified by CLI argument.
• Broadcast - written to every client_session->fd_s2c; clients update in their broadcast thread.

# Build default (COMP2017) version make clean && make all #build (COMP9017) version make comp9017 # Start server ./server <TIME-INTERVAL> # Start client ./client <SERVER_PID> <USER_NAME>