1+ // +build ignore
2+ package main
3+
4+ import (
5+ "C"
6+ "strings"
7+
8+ "golang.org/x/crypto/ssh"
9+ "gopkg.in/src-d/go-git.v3/clients/http"
10+ gssh "gopkg.in/src-d/go-git.v3/clients/ssh"
11+ )
12+
13+ //export c_NewBasicAuth
14+ func c_NewBasicAuth (username , password string ) uint64 {
15+ auth := http .NewBasicAuth (CopyString (username ), CopyString (password ))
16+ return uint64 (RegisterObject (auth ))
17+ }
18+
19+ //export c_ParseRawPrivateKey
20+ func c_ParseRawPrivateKey (pemBytes []byte ) (uint64 , int , * C.char ) {
21+ pkey , err := ssh .ParseRawPrivateKey (pemBytes )
22+ if err != nil {
23+ return IH , ErrorCodeInternal , C .CString (err .Error ())
24+ }
25+ // pointer is received - no need for &
26+ return uint64 (RegisterObject (pkey )), ErrorCodeSuccess , nil
27+ }
28+
29+ //export c_ParsePrivateKey
30+ func c_ParsePrivateKey (pemBytes []byte ) (uint64 , int , * C.char ) {
31+ signer , err := ssh .ParsePrivateKey (pemBytes )
32+ if err != nil {
33+ return IH , ErrorCodeInternal , C .CString (err .Error ())
34+ }
35+ return uint64 (RegisterObject (& signer )), ErrorCodeSuccess , nil
36+ }
37+
38+ //export c_NewPublicKey
39+ func c_NewPublicKey (key uint64 ) (uint64 , int , * C.char ) {
40+ obj , ok := GetObject (Handle (key ))
41+ if ! ok {
42+ return IH , ErrorCodeNotFound , C .CString (MessageNotFound )
43+ }
44+ key_obj := obj .(ssh.PublicKey )
45+ pkey , err := ssh .NewPublicKey (key_obj )
46+ if err != nil {
47+ return IH , ErrorCodeInternal , C .CString (err .Error ())
48+ }
49+ return uint64 (RegisterObject (& pkey )), ErrorCodeSuccess , nil
50+ }
51+
52+ //export c_NewSignerFromKey
53+ func c_NewSignerFromKey (key uint64 ) (uint64 , int , * C.char ) {
54+ obj , ok := GetObject (Handle (key ))
55+ if ! ok {
56+ return IH , ErrorCodeNotFound , C .CString (MessageNotFound )
57+ }
58+ signer , err := ssh .NewSignerFromKey (obj )
59+ if err != nil {
60+ return IH , ErrorCodeInternal , C .CString (err .Error ())
61+ }
62+ return uint64 (RegisterObject (& signer )), ErrorCodeSuccess , nil
63+ }
64+
65+ //export c_MarshalAuthorizedKey
66+ func c_MarshalAuthorizedKey (key uint64 ) (* C.char , int ) {
67+ obj , ok := GetObject (Handle (key ))
68+ if ! ok {
69+ return nil , 0
70+ }
71+ obj_key := obj .(ssh.PublicKey )
72+ mak := ssh .MarshalAuthorizedKey (obj_key )
73+ return C .CString (string (mak )), len (mak )
74+ }
75+
76+ //export c_ParsePublicKey
77+ func c_ParsePublicKey (in []byte ) (uint64 , int , * C.char ) {
78+ pkey , err := ssh .ParsePublicKey (in )
79+ if err != nil {
80+ return IH , ErrorCodeInternal , C .CString (err .Error ())
81+ }
82+ return uint64 (RegisterObject (& pkey )), ErrorCodeSuccess , nil
83+ }
84+
85+ //export c_ParseAuthorizedKey
86+ func c_ParseAuthorizedKey (in []byte ) (uint64 , * C.char , * C.char , * C.char , int , int , * C.char ) {
87+ pkey , comment , options , rest , err := ssh .ParseAuthorizedKey (in )
88+ if err != nil {
89+ return IH , nil , nil , nil , 0 , ErrorCodeInternal ,
90+ C .CString (err .Error ())
91+ }
92+ pkey_handle := RegisterObject (& pkey )
93+ mopt := strings .Join (options , "\xff " )
94+ return uint64 (pkey_handle ), C .CString (comment ), C .CString (mopt ),
95+ C .CString (string (rest )), len (rest ), ErrorCodeSuccess , nil
96+ }
97+
98+ //export c_ssh_Password_New
99+ func c_ssh_Password_New (user , pass string ) uint64 {
100+ obj := gssh.Password {User : CopyString (user ), Pass : CopyString (pass )}
101+ return uint64 (RegisterObject (& obj ))
102+ }
103+
104+ //export c_ssh_Password_get_User
105+ func c_ssh_Password_get_User (p uint64 ) * C.char {
106+ obj , ok := GetObject (Handle (p ))
107+ if ! ok {
108+ return nil
109+ }
110+ return C .CString (obj .(* gssh.Password ).User )
111+ }
112+
113+ //export c_ssh_Password_set_User
114+ func c_ssh_Password_set_User (p uint64 , v string ) {
115+ obj , ok := GetObject (Handle (p ))
116+ if ! ok {
117+ return
118+ }
119+ obj .(* gssh.Password ).User = CopyString (v )
120+ }
121+
122+ //export c_ssh_Password_get_Pass
123+ func c_ssh_Password_get_Pass (p uint64 ) * C.char {
124+ obj , ok := GetObject (Handle (p ))
125+ if ! ok {
126+ return nil
127+ }
128+ return C .CString (obj .(* gssh.Password ).Pass )
129+ }
130+
131+ //export c_ssh_Password_set_Pass
132+ func c_ssh_Password_set_Pass (p uint64 , v string ) {
133+ obj , ok := GetObject (Handle (p ))
134+ if ! ok {
135+ return
136+ }
137+ obj .(* gssh.Password ).Pass = CopyString (v )
138+ }
139+
140+ //c_ssh_PublicKeys_New
141+ func c_ssh_PublicKeys_New (user string , signer uint64 ) uint64 {
142+ obj , ok := GetObject (Handle (signer ))
143+ if ! ok {
144+ return IH
145+ }
146+ pk := gssh.PublicKeys {User : CopyString (user ), Signer : obj .(ssh.Signer )}
147+ return uint64 (RegisterObject (& pk ))
148+ }
149+
150+ //export c_ssh_PublicKeys_get_User
151+ func c_ssh_PublicKeys_get_User (p uint64 ) * C.char {
152+ obj , ok := GetObject (Handle (p ))
153+ if ! ok {
154+ return nil
155+ }
156+ return C .CString (obj .(* gssh.PublicKeys ).User )
157+ }
158+
159+ //export c_ssh_PublicKeys_set_User
160+ func c_ssh_PublicKeys_set_User (p uint64 , v string ) {
161+ obj , ok := GetObject (Handle (p ))
162+ if ! ok {
163+ return
164+ }
165+ obj .(* gssh.PublicKeys ).User = CopyString (v )
166+ }
167+
168+ //export c_ssh_PublicKeys_get_Signer
169+ func c_ssh_PublicKeys_get_Signer (p uint64 ) uint64 {
170+ obj , ok := GetObject (Handle (p ))
171+ if ! ok {
172+ return IH
173+ }
174+ handle , ok := GetHandle (& obj .(* gssh.PublicKeys ).Signer )
175+ if ! ok {
176+ return IH
177+ }
178+ return uint64 (handle )
179+ }
180+
181+ //export c_ssh_PublicKeys_set_Signer
182+ func c_ssh_PublicKeys_set_Signer (p uint64 , v uint64 ) {
183+ obj , ok := GetObject (Handle (p ))
184+ if ! ok {
185+ return
186+ }
187+ signer , ok := GetObject (Handle (v ))
188+ if ! ok {
189+ return
190+ }
191+ obj .(* gssh.PublicKeys ).Signer = * signer .(* ssh.Signer )
192+ }
0 commit comments