simple sftp server done.

Author: gjz010

.gitignore

@@ -0,0 +1,2 @@
+*.o
+file_server

Makefile

@@ -0,0 +1,21 @@
+CFLAGS=-std=c99 -O2 -w
+all: file_server
+file.o: file.c file.h
+	gcc $(CFLAGS) file.c -c -o file.o
+poll.o: poll.c poll.h
+	gcc $(CFLAGS) poll.c -c -o poll.o
+coroutine.o: coroutine.c coroutine.h switch.S
+	gcc $(CFLAGS) coroutine.c -c -o coroutine.o
+switch.o: switch.S
+	gcc $(CFLAGS) switch.S -c -o switch.o
+main.o: main.c
+	gcc $(CFLAGS) main.c -c -o main.o
+listen_server.o: listen_server.c listen_server.h
+	gcc $(CFLAGS) listen_server.c -c -o listen_server.o
+sftp.o: sftp.c
+	gcc $(CFLAGS) sftp.c -c -o sftp.o
+file_server: file.o poll.o coroutine.o sftp.o switch.o main.o listen_server.o
+	gcc $(CFLAGS) file.o poll.o coroutine.o sftp.o switch.o listen_server.o main.o -o file_server
+.PHONY: clean
+clean:
+	rm *.o file_server

coroutine.c

@@ -0,0 +1,73 @@
+#include "coroutine.h"
+#include <assert.h>
+#include <stdlib.h>
+coroutine* current_coroutine;
+coroutine* root_coroutine;
+int context_switch(context* cfrom, context* cto);
+
+void coroutine_entry(coroutine_func f, void* arg){
+    f(arg);
+    current_coroutine->state=1; //tag finished
+    coroutine_yield(); //as a normal yield.
+}
+void coroutine_start(coroutine* c, coroutine_func entry, void* arg){
+    c->caller=0;
+    c->stack=malloc(STACK_SIZE);
+    c->state=0;
+    memset(&c->c_context, 0, sizeof(context));
+    c->c_context.rsp=c->stack+STACK_SIZE;
+    // return rip does not matter.
+    c->c_context.rdi=entry;
+    c->c_context.rsi=arg;
+    //*(uint64_t)(c->c_context.rsp+8)=entry; //the entry.
+    //*(uint64_t)(c->c_context.rsp+16)=arg; //the arg.
+    c->c_context.rbp=c->stack+STACK_SIZE;
+    c->c_context.rip=&coroutine_entry;
+    // everything is ready now, and only requires a trigger.
+    //printf("%d %d\n", c, c->stack);
+}
+
+
+void coroutine_yield(){
+    assert(current_coroutine!=root_coroutine); // root coroutine should not be yielded.
+    context* current_context=&current_coroutine->c_context;
+    context* parent_context=&current_coroutine->caller->c_context;
+    coroutine* parent=current_coroutine->caller;
+    current_coroutine->caller=0;
+    current_coroutine=parent;
+    context_switch(current_context, parent_context);
+}
+
+
+int coroutine_await(coroutine* target){
+    assert(target->caller==0);
+    assert(target->state==0);
+    context* current_context=&current_coroutine->c_context;
+    target->caller=current_coroutine;
+    current_coroutine=target;
+    context* new_context=&current_coroutine->c_context;
+    context_switch(current_context, new_context);
+    // After some hard work we gain control again.
+    // now we just free the coroutine.
+    if(target->state==0){
+        return 0;
+    }else{
+        coroutine_destroy(target);
+        return 1;
+    }
+}
+
+void coroutine_init(){
+    // In fact nothing is done.
+    // root_coroutine is the place to store registers.
+    root_coroutine=(coroutine*)malloc(sizeof(coroutine));
+    current_coroutine=root_coroutine;
+}
+
+void coroutine_destroy(coroutine* co){
+    assert(co->state==1);
+    //printf("%d %d\n", co, co->stack);
+    free(co->stack);
+    //printf("stack\n");
+    free(co);
+}

coroutine.h

@@ -0,0 +1,57 @@
+#pragma once
+// Let's base our entire work on this coroutine.
+// Coroutine makes our life easier.
+// For example, when dealing with protocols we no longer need to deal with state machines, but deal with fiber scheduling,
+
+// A coroutine supports three options：
+// 1. start: this starts a coroutine.
+// 2. yield: throws out a value to outer coroutine.
+// 3. await: transfers control to the coroutine. when control is regained,
+//           a value is fetched from the coroutine.
+
+// Allocate 64KB stack memory.
+// This is much cheaper than fork or pthread or something.
+#include "sys/types.h"
+#include "stdint.h"
+#include "setjmp.h"
+#define STACK_SIZE 65536
+// RAX register is always the scratch.
+typedef struct {
+    uint64_t rip;
+    uint64_t rsp;
+    uint64_t rbx;
+    uint64_t rcx;
+    uint64_t rdx;
+    uint64_t rsi;
+    uint64_t rdi;
+    uint64_t rbp;
+    uint64_t r8;
+    uint64_t r9;
+    uint64_t r10;
+    uint64_t r11;
+    uint64_t r12;
+    uint64_t r13;
+    uint64_t r14;
+    uint64_t r15;
+} context;
+
+typedef struct tag_coroutine{
+    struct tag_coroutine* caller;
+    context c_context;
+    uint8_t* stack;
+    int state;
+    jmp_buf exception_env;
+} coroutine;
+#define coroutine_catch (setjmp(current_coroutine->exception_env))
+#define coroutine_throw {do{longjmp(current_coroutine->exception_env, 1);}while(0);}
+extern coroutine* current_coroutine;
+extern coroutine* root_coroutine;
+
+typedef void (*coroutine_func)(void*);
+
+// Set the main process as the outer-most coroutine.
+void coroutine_init();
+void coroutine_start(coroutine* c, coroutine_func entry, void* arg);
+void coroutine_yield();
+int coroutine_await();
+void coroutine_destroy(coroutine* co);