My Project
Functions
ssiLink.h File Reference
#include "Singular/links/silink.h"

Go to the source code of this file.

Functions

BOOLEAN ssiOpen (si_link l, short flag, leftv u)
 
BOOLEAN ssiWrite (si_link l, leftv v)
 
leftv ssiRead1 (si_link l)
 
leftv ssiRead2 (si_link l, leftv key)
 
BOOLEAN ssiClose (si_link l)
 
const char * slStatusSsi (si_link l, const char *request)
 
si_link_extension slInitSsiExtension (si_link_extension s)
 
si_link ssiCommandLink ()
 
void sig_chld_hdl (int sig)
 additional default signal handler More...
 
int ssiReservePort (int clients)
 

Function Documentation

◆ sig_chld_hdl()

void sig_chld_hdl ( int  sig)

additional default signal handler

some newer Linux version cannot have SIG_IGN for SIGCHLD, so use this nice routine here: SuSe 9.x reports -1 always Redhat 9.x/FC x reports sometimes -1 see also: hpux_system also needed by getrusage (timer etc.)

Parameters
[in]sig

Definition at line 2186 of file ssiLink.cc.

2187{
2188 pid_t kidpid;
2189 int status;
2190
2191 loop
2192 {
2193 kidpid = si_waitpid(-1, &status, WNOHANG);
2194 if (kidpid==-1)
2195 {
2196 /* continue on interruption (EINTR): */
2197 if (errno == EINTR) continue;
2198 /* break on anything else (EINVAL or ECHILD according to manpage): */
2199 break;
2200 }
2201 else if (kidpid==0) break; /* no more children to process, so break */
2202
2203 //printf("Child %ld terminated\n", kidpid);
2205 while((hh!=NULL)&&(ssiToBeClosed_inactive))
2206 {
2207 if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2208 {
2209 ssiInfo *d = (ssiInfo *)hh->l->data;
2210 if(d->pid==kidpid)
2211 {
2213 {
2215 slClose(hh->l);
2217 break;
2218 }
2219 else break;
2220 }
2221 else hh=(link_list)hh->next;
2222 }
2223 else hh=(link_list)hh->next;
2224 }
2225 }
2226}
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
#define NULL
Definition: omList.c:12
pid_t pid
Definition: s_buff.h:25
Definition: s_buff.h:21
int * status
Definition: si_signals.h:51
#define loop
Definition: structs.h:75

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1799 of file ssiLink.cc.

1800{
1801 s->Open=ssiOpen;
1802 s->Close=ssiClose;
1803 s->Kill=ssiClose;
1804 s->Read=ssiRead1;
1805 s->Read2=(slRead2Proc)NULL;
1806 s->Write=ssiWrite;
1807 s->Dump=ssiDump;
1808 s->GetDump=ssiGetDump;
1809
1810 s->Status=slStatusSsi;
1811 s->SetRing=ssiSetRing;
1812 s->type="ssi";
1813 return s;
1814}
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ slStatusSsi()

const char * slStatusSsi ( si_link  l,
const char *  request 
)

Definition at line 1816 of file ssiLink.cc.

1817{
1818 ssiInfo *d=(ssiInfo*)l->data;
1819 if (d==NULL) return "not open";
1820 if (((strcmp(l->mode,"fork")==0)
1821 ||(strcmp(l->mode,"tcp")==0)
1822 ||(strcmp(l->mode,"connect")==0))
1823 && (strcmp(request, "read") == 0))
1824 {
1825 fd_set mask;
1826 struct timeval wt;
1827 if (s_isready(d->f_read)) return "ready";
1828 loop
1829 {
1830 /* Don't block. Return socket status immediately. */
1831 wt.tv_sec = 0;
1832 wt.tv_usec = 0;
1833
1834 FD_ZERO(&mask);
1835 FD_SET(d->fd_read, &mask);
1836 //Print("test fd %d\n",d->fd_read);
1837 /* check with select: chars waiting: no -> not ready */
1838 switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1839 {
1840 case 0: /* not ready */ return "not ready";
1841 case -1: /*error*/ return "error";
1842 case 1: /*ready ? */ break;
1843 }
1844 /* yes: read 1 char*/
1845 /* if \n, check again with select else ungetc(c), ready*/
1846 int c=s_getc(d->f_read);
1847 //Print("try c=%d\n",c);
1848 if (c== -1) return "eof"; /* eof or error */
1849 else if (isdigit(c))
1850 { s_ungetc(c,d->f_read); return "ready"; }
1851 else if (c>' ')
1852 {
1853 Werror("unknown char in ssiLink(%d)",c);
1854 return "error";
1855 }
1856 /* else: next char */
1857 }
1858 }
1859 else if (strcmp(request, "read") == 0)
1860 {
1861 if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1862 else return "not ready";
1863 }
1864 else if (strcmp(request, "write") == 0)
1865 {
1866 if (SI_LINK_W_OPEN_P(l)) return "ready";
1867 else return "not ready";
1868 }
1869 else return "unknown status request";
1870}
int l
Definition: cfEzgcd.cc:100
if(!FE_OPT_NO_SHELL_FLAG)(void) system(sys)
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int s_getc(s_buff F)
Definition: s_buff.cc:58
int s_isready(s_buff F)
Definition: s_buff.cc:85
int s_iseof(s_buff F)
Definition: s_buff.cc:254
void s_ungetc(int c, s_buff F)
Definition: s_buff.cc:99
s_buff f_read
Definition: s_buff.h:22
int fd_read
Definition: s_buff.h:26

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1371 of file ssiLink.cc.

1372{
1373 if (l!=NULL)
1374 {
1376 ssiInfo *d = (ssiInfo *)l->data;
1377 if (d!=NULL)
1378 {
1379 // send quit signal
1380 if ((d->send_quit_at_exit)
1381 && (d->quit_sent==0))
1382 {
1383 fputs("99\n",d->f_write);
1384 fflush(d->f_write);
1385 }
1386 // clean ring
1387 if (d->r!=NULL) rKill(d->r);
1388 for(int i=0;i<SI_RING_CACHE;i++)
1389 {
1390 if (d->rings[i]!=NULL) rKill(d->rings[i]);
1391 d->rings[i]=NULL;
1392 }
1393 // did the child to stop ?
1394 si_waitpid(d->pid,NULL,WNOHANG);
1395 if ((d->pid!=0)
1396 && (kill(d->pid,0)==0)) // child is still running
1397 {
1398 struct timespec t;
1399 t.tv_sec=0;
1400 t.tv_nsec=100000000; // <=100 ms
1401 struct timespec rem;
1402 int r;
1403 loop
1404 {
1405 // wait till signal or time rem:
1406 r = nanosleep(&t, &rem);
1407 t = rem;
1408 // child finished:
1409 if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1410 // other signal, waited s>= 100 ms:
1411 if ((r==0) || (errno != EINTR)) break;
1412 }
1413 if (kill(d->pid,0) == 0) // pid still exists
1414 {
1415 kill(d->pid,15);
1416 t.tv_sec=5; // <=5s
1417 t.tv_nsec=0;
1418 loop
1419 {
1420 // wait till signal or time rem:
1421 r = nanosleep(&t, &rem);
1422 t = rem;
1423 // child finished:
1424 if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1425 // other signal, waited s>= 5 s:
1426 if ((r==0) || (errno != EINTR)) break;
1427 }
1428 if (kill(d->pid,0) == 0)
1429 {
1430 kill(d->pid,9); // just to be sure
1431 si_waitpid(d->pid,NULL,0);
1432 }
1433 }
1434 }
1435 if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1436 if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1437 if ((strcmp(l->mode,"tcp")==0)
1438 || (strcmp(l->mode,"fork")==0))
1439 {
1441 if (hh!=NULL)
1442 {
1443 if (hh->l==l)
1444 {
1446 omFreeSize(hh,sizeof(link_struct));
1447 }
1448 else while(hh->next!=NULL)
1449 {
1450 link_list hhh=(link_list)hh->next;
1451 if (hhh->l==l)
1452 {
1453 hh->next=hhh->next;
1454 omFreeSize(hhh,sizeof(link_struct));
1455 break;
1456 }
1457 else
1458 hh=(link_list)hh->next;
1459 }
1460 }
1461 }
1462 omFreeSize((ADDRESS)d,(sizeof *d));
1463 }
1464 l->data=NULL;
1465 }
1466 return FALSE;
1467}
void * ADDRESS
Definition: auxiliary.h:119
int i
Definition: cfEzgcd.cc:132
void rKill(ring r)
Definition: ipshell.cc:6182
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
int s_close(s_buff &F)
Definition: s_buff.cc:45
ring rings[SI_RING_CACHE]
Definition: s_buff.h:31
#define SI_RING_CACHE
Definition: s_buff.h:30
char send_quit_at_exit
Definition: s_buff.h:28
char quit_sent
Definition: s_buff.h:29
FILE * f_write
Definition: s_buff.h:23
ring r
Definition: s_buff.h:24

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 2115 of file ssiLink.cc.

2116{
2117 if (ssiReserved_P==0)
2118 {
2119 WerrorS("ERROR no reserved port requested");
2120 return NULL;
2121 }
2122 struct sockaddr_in cli_addr;
2123 int clilen = sizeof(cli_addr);
2124 int newsockfd = si_accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
2125 if(newsockfd < 0)
2126 {
2127 Werror("ERROR on accept (errno=%d)",errno);
2128 return NULL;
2129 }
2131 si_link_extension s = si_link_root;
2132 si_link_extension prev = s;
2133 while (strcmp(s->type, "ssi") != 0)
2134 {
2135 if (s->next == NULL)
2136 {
2137 prev = s;
2138 s = NULL;
2139 break;
2140 }
2141 else
2142 {
2143 s = s->next;
2144 }
2145 }
2146 if (s != NULL)
2147 l->m = s;
2148 else
2149 {
2150 si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
2151 prev->next=slInitSsiExtension(ns);
2152 l->m = prev->next;
2153 }
2154 l->name=omStrDup("");
2155 l->mode=omStrDup("tcp");
2156 l->ref=1;
2157 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2158 l->data=d;
2159 d->fd_read = newsockfd;
2160 d->fd_write = newsockfd;
2161 d->f_read = s_open(newsockfd);
2162 d->f_write = fdopen(newsockfd, "w");
2165 if (ssiReserved_Clients<=0)
2166 {
2167 ssiReserved_P=0;
2168 si_close(ssiReserved_sockfd);
2169 }
2170 return l;
2171}
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omAlloc0(size)
Definition: omAllocDecl.h:211
s_buff s_open(int fd)
Definition: s_buff.cc:31
int fd_write
Definition: s_buff.h:26

◆ ssiOpen()

BOOLEAN ssiOpen ( si_link  l,
short  flag,
leftv  u 
)

Definition at line 957 of file ssiLink.cc.

958{
959 if (l!=NULL)
960 {
961 const char *mode;
962 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
963 if (flag & SI_LINK_OPEN)
964 {
965 if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
966 flag = SI_LINK_READ;
967 else flag = SI_LINK_WRITE;
968 }
969
970 if (flag == SI_LINK_READ) mode = "r";
971 else if (strcmp(l->mode, "w") == 0) mode = "w";
972 else if (strcmp(l->mode, "fork") == 0) mode = "fork";
973 else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
974 else if (strcmp(l->mode, "connect") == 0) mode = "connect";
975 else mode = "a";
976
977
978 SI_LINK_SET_OPEN_P(l, flag);
979 if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
980 l->data=d;
981 omFreeBinAddr(l->mode);
982 l->mode = omStrDup(mode);
983
984 if (l->name[0] == '\0')
985 {
986 if (strcmp(mode,"fork")==0)
987 {
989 n->u=u;
990 n->l=l;
991 n->next=(void *)ssiToBeClosed;
993
994 int pc[2];
995 int cp[2];
996 pipe(pc);
997 pipe(cp);
998 pid_t pid = fork();
999 if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
1000 {
1002 pid = fork();
1003 }
1004 if (pid == -1)
1005 {
1006 WerrorS("could not fork");
1007 }
1008 if (pid==0) /*fork: child*/
1009 {
1010 /* block SIGINT */
1011 sigset_t sigint;
1012 sigemptyset(&sigint);
1013 sigaddset(&sigint, SIGINT);
1014 sigprocmask(SIG_BLOCK, &sigint, NULL);
1015 /* set #cpu to 1 for the child:*/
1016 feSetOptValue(FE_OPT_CPUS,1);
1017
1019 /* we know: l is the first entry in ssiToBeClosed-list */
1020 while(hh!=NULL)
1021 {
1023 ssiInfo *dd=(ssiInfo*)hh->l->data;
1024 s_close(dd->f_read);
1025 fclose(dd->f_write);
1026 if (dd->r!=NULL) rKill(dd->r);
1027 omFreeSize((ADDRESS)dd,(sizeof *dd));
1028 hh->l->data=NULL;
1029 link_list nn=(link_list)hh->next;
1030 omFree(hh);
1031 hh=nn;
1032 }
1034#ifdef HAVE_SIMPLEIPC
1035 memset(sem_acquired, 0, SIPC_MAX_SEMAPHORES*sizeof(sem_acquired[0]));
1036#endif // HAVE_SIMPLEIPC
1037 si_close(pc[1]); si_close(cp[0]);
1038 d->f_write=fdopen(cp[1],"w");
1039 d->f_read=s_open(pc[0]);
1040 d->fd_read=pc[0];
1041 d->fd_write=cp[1];
1042 //d->r=currRing;
1043 //if (d->r!=NULL) d->r->ref++;
1044 l->data=d;
1045 omFreeBinAddr(l->mode);
1046 l->mode = omStrDup(mode);
1049 //myynest=0;
1051 if ((u!=NULL)&&(u->rtyp==IDHDL))
1052 {
1053 idhdl h=(idhdl)u->data;
1054 h->lev=0;
1055 }
1056 loop
1057 {
1058 if (!SI_LINK_OPEN_P(l)) m2_end(0);
1059 if(d->f_read->is_eof) m2_end(0);
1060 leftv h=ssiRead1(l); /*contains an exit.... */
1061 if (feErrors != NULL && *feErrors != '\0')
1062 {
1063 // handle errors:
1064 PrintS(feErrors); /* currently quite simple */
1065 *feErrors = '\0';
1066 }
1067 ssiWrite(l,h);
1068 h->CleanUp();
1070 }
1071 /* never reached*/
1072 }
1073 else if (pid>0) /*fork: parent*/
1074 {
1075 d->pid=pid;
1076 si_close(pc[0]); si_close(cp[1]);
1077 d->f_write=fdopen(pc[1],"w");
1078 d->f_read=s_open(cp[0]);
1079 d->fd_read=cp[0];
1080 d->fd_write=pc[1];
1082 d->send_quit_at_exit=1;
1083 //d->r=currRing;
1084 //if (d->r!=NULL) d->r->ref++;
1085 }
1086 else
1087 {
1088 Werror("fork failed (%d)",errno);
1089 l->data=NULL;
1090 omFree(d);
1091 return TRUE;
1092 }
1093 }
1094 // ---------------------------------------------------------------------
1095 else if (strcmp(mode,"tcp")==0)
1096 {
1097 int sockfd, newsockfd, portno, clilen;
1098 struct sockaddr_in serv_addr, cli_addr;
1099 sockfd = socket(AF_INET, SOCK_STREAM, 0);
1100 if(sockfd < 0)
1101 {
1102 WerrorS("ERROR opening socket");
1103 l->data=NULL;
1104 l->flags=0;
1105 omFree(d);
1106 return TRUE;
1107 }
1108 memset((char *) &serv_addr,0, sizeof(serv_addr));
1109 portno = 1025;
1110 serv_addr.sin_family = AF_INET;
1111 serv_addr.sin_addr.s_addr = INADDR_ANY;
1112 do
1113 {
1114 portno++;
1115 serv_addr.sin_port = htons(portno);
1116 if(portno > 50000)
1117 {
1118 WerrorS("ERROR on binding (no free port available?)");
1119 l->data=NULL;
1120 l->flags=0;
1121 omFree(d);
1122 return TRUE;
1123 }
1124 }
1125 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1126 Print("waiting on port %d\n", portno);mflush();
1127 listen(sockfd,1);
1128 newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1129 if(newsockfd < 0)
1130 {
1131 WerrorS("ERROR on accept");
1132 l->data=NULL;
1133 l->flags=0;
1134 omFree(d);
1135 return TRUE;
1136 }
1137 PrintS("client accepted\n");
1138 d->fd_read = newsockfd;
1139 d->fd_write = newsockfd;
1140 d->f_read = s_open(newsockfd);
1141 d->f_write = fdopen(newsockfd, "w");
1143 si_close(sockfd);
1144 }
1145 // no ssi-Link on stdin or stdout
1146 else
1147 {
1148 Werror("invalid mode >>%s<< for ssi",mode);
1149 l->data=NULL;
1150 l->flags=0;
1151 omFree(d);
1152 return TRUE;
1153 }
1154 }
1155 // =========================================================================
1156 else /*l->name=NULL*/
1157 {
1158 // tcp mode
1159 if(strcmp(mode,"tcp")==0)
1160 {
1161 int sockfd, newsockfd, portno, clilen;
1162 struct sockaddr_in serv_addr, cli_addr;
1163 sockfd = socket(AF_INET, SOCK_STREAM, 0);
1164 if(sockfd < 0)
1165 {
1166 WerrorS("ERROR opening socket");
1167 l->data=NULL;
1168 l->flags=0;
1169 omFree(d);
1170 return TRUE;
1171 }
1172 memset((char *) &serv_addr,0, sizeof(serv_addr));
1173 portno = 1025;
1174 serv_addr.sin_family = AF_INET;
1175 serv_addr.sin_addr.s_addr = INADDR_ANY;
1176 do
1177 {
1178 portno++;
1179 serv_addr.sin_port = htons(portno);
1180 if(portno > 50000)
1181 {
1182 WerrorS("ERROR on binding (no free port available?)");
1183 l->data=NULL;
1184 l->flags=0;
1185 return TRUE;
1186 }
1187 }
1188 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1189 //Print("waiting on port %d\n", portno);mflush();
1190 listen(sockfd,1);
1191 char* cli_host = (char*)omAlloc(256);
1192 char* path = (char*)omAlloc(1024);
1193 int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1194 if(r == 0)
1195 {
1196 WerrorS("ERROR: no host specified");
1197 l->data=NULL;
1198 l->flags=0;
1199 omFree(d);
1200 omFree(path);
1201 omFree(cli_host);
1202 return TRUE;
1203 }
1204 else if(r == 1)
1205 {
1206 WarnS("program not specified, using /usr/local/bin/Singular");
1207 Warn("in line >>%s<<",my_yylinebuf);
1208 strcpy(path,"/usr/local/bin/Singular");
1209 }
1210 char* ssh_command = (char*)omAlloc(256);
1211 char* ser_host = (char*)omAlloc(64);
1212 gethostname(ser_host,64);
1213 if (strcmp(cli_host,"localhost")==0) /*avoid "ssh localhost" as key may change*/
1214 snprintf(ssh_command,256,"%s -q --batch --link=ssi --MPhost=%s --MPport=%d &",path,ser_host,portno);
1215 else
1216 snprintf(ssh_command,256,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1217 //Print("client on %s started:%s\n",cli_host,path);
1218 omFree(path);
1219 omFree(cli_host);
1220 if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1221 system(ssh_command);
1222 omFree(ssh_command);
1223 omFree(ser_host);
1224 clilen = sizeof(cli_addr);
1225 newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1226 if(newsockfd < 0)
1227 {
1228 WerrorS("ERROR on accept");
1229 l->data=NULL;
1230 l->flags=0;
1231 omFree(d);
1232 return TRUE;
1233 }
1234 //PrintS("client accepted\n");
1235 d->fd_read = newsockfd;
1236 d->fd_write = newsockfd;
1237 d->f_read = s_open(newsockfd);
1238 d->f_write = fdopen(newsockfd, "w");
1239 si_close(sockfd);
1241 d->send_quit_at_exit=1;
1242 link_list newlink=(link_list)omAlloc(sizeof(link_struct));
1243 newlink->u=u;
1244 newlink->l=l;
1245 newlink->next=(void *)ssiToBeClosed;
1246 ssiToBeClosed=newlink;
1247 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1248 }
1249 // ----------------------------------------------------------------------
1250 else if(strcmp(mode,"connect")==0)
1251 {
1252 char* host = (char*)omAlloc(256);
1253 int sockfd, portno;
1254 struct sockaddr_in serv_addr;
1255 struct hostent *server;
1256
1257 si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1258 //Print("connect to host %s, port %d\n",host,portno);mflush();
1259 if (portno!=0)
1260 {
1261 sockfd = socket(AF_INET, SOCK_STREAM, 0);
1262 if (sockfd < 0)
1263 {
1264 WerrorS("ERROR opening socket");
1265 l->flags=0;
1266 return TRUE;
1267 }
1268 server = gethostbyname(host);
1269 if (server == NULL)
1270 {
1271 WerrorS("ERROR, no such host");
1272 l->flags=0;
1273 return TRUE;
1274 }
1275 memset((char *) &serv_addr, 0, sizeof(serv_addr));
1276 serv_addr.sin_family = AF_INET;
1277 memcpy((char *)&serv_addr.sin_addr.s_addr,
1278 (char *)server->h_addr,
1279 server->h_length);
1280 serv_addr.sin_port = htons(portno);
1281 if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1282 {
1283 Werror("ERROR connecting(errno=%d)",errno);
1284 l->flags=0;
1285 return TRUE;
1286 }
1287 //PrintS("connected\n");mflush();
1288 d->f_read=s_open(sockfd);
1289 d->fd_read=sockfd;
1290 d->f_write=fdopen(sockfd,"w");
1291 d->fd_write=sockfd;
1293 omFree(host);
1294 }
1295 else
1296 {
1297 l->data=NULL;
1298 l->flags=0;
1299 omFree(d);
1300 return TRUE;
1301 }
1302 }
1303 // ======================================================================
1304 else
1305 {
1306 // normal link to a file
1307 FILE *outfile;
1308 char *filename=l->name;
1309
1310 if(filename[0]=='>')
1311 {
1312 if (filename[1]=='>')
1313 {
1314 filename+=2;
1315 mode = "a";
1316 }
1317 else
1318 {
1319 filename++;
1320 mode="w";
1321 }
1322 }
1323 outfile=myfopen(filename,mode);
1324 if (outfile!=NULL)
1325 {
1326 if (strcmp(l->mode,"r")==0)
1327 {
1328 fclose(outfile);
1329 d->f_read=s_open_by_name(filename);
1330 }
1331 else
1332 {
1333 d->f_write = outfile;
1334 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1335 }
1336 }
1337 else
1338 {
1339 omFree(d);
1340 l->data=NULL;
1341 l->flags=0;
1342 return TRUE;
1343 }
1344 }
1345 }
1346 }
1347
1348 return FALSE;
1349}
Definition: idrec.h:35
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int rtyp
Definition: subexpr.h:91
void * data
Definition: subexpr.h:88
VAR BOOLEAN singular_in_batchmode
Definition: cntrlc.cc:62
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
FILE * myfopen(const char *path, const char *mode)
Definition: feFopen.cc:167
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition: feOpt.cc:154
VAR char my_yylinebuf[80]
Definition: febase.cc:44
char * fe_fgets_dummy(const char *, char *, int)
Definition: feread.cc:455
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:32
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:145
STATIC_VAR Poly * h
Definition: janet.cc:971
void m2_end(int i)
Definition: misc_ip.cc:1097
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omFree(addr)
Definition: omAllocDecl.h:261
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omFreeBinAddr(addr)
Definition: omAllocDecl.h:258
VAR unsigned si_opt_2
Definition: options.c:6
VAR unsigned si_opt_1
Definition: options.c:5
#define TEST_OPT_PROT
Definition: options.h:103
void PrintS(const char *s)
Definition: reporter.cc:284
VAR char * feErrors
Definition: reporter.cc:47
#define mflush()
Definition: reporter.h:58
idrec * idhdl
Definition: ring.h:21
int raise_rlimit_nproc()
Definition: rlimit.c:18
s_buff s_open_by_name(const char *n)
Definition: s_buff.cc:39
VAR int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition: semaphore.c:25
#define SIPC_MAX_SEMAPHORES
Definition: simpleipc.h:10
#define IDHDL
Definition: tok.h:31
@ MAX_TOK
Definition: tok.h:218

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1470 of file ssiLink.cc.

1471{
1472 ssiInfo *d = (ssiInfo *)l->data;
1474 int t=0;
1475 t=s_readint(d->f_read);
1476 //Print("got type %d\n",t);
1477 switch(t)
1478 {
1479 case 1:res->rtyp=INT_CMD;
1480 res->data=(char *)(long)ssiReadInt(d->f_read);
1481 break;
1482 case 2:res->rtyp=STRING_CMD;
1483 res->data=(char *)ssiReadString(d);
1484 break;
1485 case 3:res->rtyp=NUMBER_CMD;
1486 if (d->r==NULL) goto no_ring;
1487 ssiCheckCurrRing(d->r);
1488 res->data=(char *)ssiReadNumber(d);
1489 break;
1490 case 4:res->rtyp=BIGINT_CMD;
1491 res->data=(char *)ssiReadBigInt(d);
1492 break;
1493 case 15:
1494 case 5:{
1495 d->r=ssiReadRing(d);
1496 if (errorreported) return NULL;
1497 res->data=(char*)d->r;
1498 if (d->r!=NULL) rIncRefCnt(d->r);
1499 res->rtyp=RING_CMD;
1500 if (t==15) // setring
1501 {
1502 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1504 return ssiRead1(l);
1505 }
1506 }
1507 break;
1508 case 6:res->rtyp=POLY_CMD;
1509 if (d->r==NULL) goto no_ring;
1510 ssiCheckCurrRing(d->r);
1511 res->data=(char*)ssiReadPoly(d);
1512 break;
1513 case 7:res->rtyp=IDEAL_CMD;
1514 if (d->r==NULL) goto no_ring;
1515 ssiCheckCurrRing(d->r);
1516 res->data=(char*)ssiReadIdeal(d);
1517 break;
1518 case 8:res->rtyp=MATRIX_CMD;
1519 if (d->r==NULL) goto no_ring;
1520 ssiCheckCurrRing(d->r);
1521 res->data=(char*)ssiReadMatrix(d);
1522 break;
1523 case 9:res->rtyp=VECTOR_CMD;
1524 if (d->r==NULL) goto no_ring;
1525 ssiCheckCurrRing(d->r);
1526 res->data=(char*)ssiReadPoly(d);
1527 break;
1528 case 10:
1529 case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1530 else res->rtyp=MODUL_CMD;
1531 if (d->r==NULL) goto no_ring;
1532 ssiCheckCurrRing(d->r);
1533 {
1534 int rk=s_readint(d->f_read);
1535 ideal M=ssiReadIdeal(d);
1536 M->rank=rk;
1537 res->data=(char*)M;
1538 }
1539 break;
1540 case 11:
1541 {
1542 res->rtyp=COMMAND;
1543 res->data=ssiReadCommand(l);
1544 int nok=res->Eval();
1545 if (nok) WerrorS("error in eval");
1546 break;
1547 }
1548 case 12: /*DEF_CMD*/
1549 {
1550 res->rtyp=0;
1551 res->name=(char *)ssiReadString(d);
1552 int nok=res->Eval();
1553 if (nok) WerrorS("error in name lookup");
1554 break;
1555 }
1556 case 13: res->rtyp=PROC_CMD;
1557 res->data=ssiReadProc(d);
1558 break;
1559 case 14: res->rtyp=LIST_CMD;
1560 res->data=ssiReadList(l);
1561 break;
1562 case 16: res->rtyp=NONE; res->data=NULL;
1563 break;
1564 case 17: res->rtyp=INTVEC_CMD;
1565 res->data=ssiReadIntvec(d);
1566 break;
1567 case 18: res->rtyp=INTMAT_CMD;
1568 res->data=ssiReadIntmat(d);
1569 break;
1570 case 19: res->rtyp=BIGINTMAT_CMD;
1571 res->data=ssiReadBigintmat(d);
1572 break;
1573 case 20: ssiReadBlackbox(res,l);
1574 break;
1575 case 21: ssiReadAttrib(res,l);
1576 break;
1577 case 23: ssiReadRingProperties(l);
1578 return ssiRead1(l);
1579 break;
1580 // ------------
1581 case 98: // version
1582 {
1583 int n98_v,n98_m;
1584 BITSET n98_o1,n98_o2;
1585 n98_v=s_readint(d->f_read);
1586 n98_m=s_readint(d->f_read);
1587 n98_o1=s_readint(d->f_read);
1588 n98_o2=s_readint(d->f_read);
1589 if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1590 {
1591 Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1592 SSI_VERSION,MAX_TOK,n98_v,n98_m);
1593 }
1594 #ifndef SING_NDEBUG
1595 if (TEST_OPT_DEBUG)
1596 Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1597 #endif
1598 si_opt_1=n98_o1;
1599 si_opt_2=n98_o2;
1601 return ssiRead1(l);
1602 }
1603 case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1604 case 0: if (s_iseof(d->f_read))
1605 {
1606 ssiClose(l);
1607 }
1608 res->rtyp=DEF_CMD;
1609 break;
1610 default: Werror("not implemented (t:%d)",t);
1612 res=NULL;
1613 break;
1614 }
1615 // if currRing is required for the result, but lost
1616 // define "ssiRing%d" as currRing:
1617 if ((d->r!=NULL)
1618 && (currRing!=d->r)
1619 && (res->RingDependend()))
1620 {
1621 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1622 }
1623 return res;
1624no_ring: WerrorS("no ring");
1626 return NULL;
1627}
CanonicalForm res
Definition: facAbsFact.cc:60
VAR short errorreported
Definition: feFopen.cc:23
@ IDEAL_CMD
Definition: grammar.cc:284
@ MATRIX_CMD
Definition: grammar.cc:286
@ BIGINTMAT_CMD
Definition: grammar.cc:278
@ PROC_CMD
Definition: grammar.cc:280
@ INTMAT_CMD
Definition: grammar.cc:279
@ MODUL_CMD
Definition: grammar.cc:287
@ SMATRIX_CMD
Definition: grammar.cc:291
@ VECTOR_CMD
Definition: grammar.cc:292
@ NUMBER_CMD
Definition: grammar.cc:288
@ POLY_CMD
Definition: grammar.cc:289
@ RING_CMD
Definition: grammar.cc:281
#define TEST_OPT_DEBUG
Definition: options.h:108
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static ring rIncRefCnt(ring r)
Definition: ring.h:839
int s_readint(s_buff F)
Definition: s_buff.cc:112
#define M
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:16
@ BIGINT_CMD
Definition: tok.h:38
@ LIST_CMD
Definition: tok.h:118
@ INTVEC_CMD
Definition: tok.h:101
@ DEF_CMD
Definition: tok.h:58
@ STRING_CMD
Definition: tok.h:185
@ INT_CMD
Definition: tok.h:96
#define NONE
Definition: tok.h:221
#define COMMAND
Definition: tok.h:29

◆ ssiRead2()

leftv ssiRead2 ( si_link  l,
leftv  key 
)

◆ ssiReservePort()

int ssiReservePort ( int  clients)

Definition at line 2079 of file ssiLink.cc.

2080{
2081 if (ssiReserved_P!=0)
2082 {
2083 WerrorS("ERROR already a reserved port requested");
2084 return 0;
2085 }
2086 int portno;
2087 ssiReserved_sockfd = socket(AF_INET, SOCK_STREAM, 0);
2088 if(ssiReserved_sockfd < 0)
2089 {
2090 WerrorS("ERROR opening socket");
2091 return 0;
2092 }
2093 memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
2094 portno = 1025;
2095 ssiResverd_serv_addr.sin_family = AF_INET;
2096 ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
2097 do
2098 {
2099 portno++;
2100 ssiResverd_serv_addr.sin_port = htons(portno);
2101 if(portno > 50000)
2102 {
2103 WerrorS("ERROR on binding (no free port available?)");
2104 return 0;
2105 }
2106 }
2107 while(bind(ssiReserved_sockfd, (struct sockaddr *) &ssiResverd_serv_addr, sizeof(ssiResverd_serv_addr)) < 0);
2108 ssiReserved_P=portno;
2109 listen(ssiReserved_sockfd,clients);
2110 ssiReserved_Clients=clients;
2111 return portno;
2112}

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1648 of file ssiLink.cc.

1649{
1650 if(SI_LINK_W_OPEN_P(l)==0)
1652 ssiInfo *d = (ssiInfo *)l->data;
1653 d->level++;
1654 //FILE *fich=d->f;
1655 while (data!=NULL)
1656 {
1657 int tt=data->Typ();
1658 void *dd=data->Data();
1659 attr *aa=data->Attribute();
1660 if ((aa!=NULL) && ((*aa)!=NULL)) // n user attributes
1661 {
1662 attr a=*aa;
1663 int n=0;
1664 while(a!=NULL) { n++; a=a->next;}
1665 fprintf(d->f_write,"21 %d %d ",data->flag,n);
1666 }
1667 else if (data->flag!=0) // only "flag" attributes
1668 {
1669 fprintf(d->f_write,"21 %d 0 ",data->flag);
1670 }
1671 if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1672 // return pure undefined names as def
1673
1674 switch(tt /*data->Typ()*/)
1675 {
1676 case 0: /*error*/
1677 case NONE/* nothing*/:fputs("16 ",d->f_write);
1678 break;
1679 case STRING_CMD: fputs("2 ",d->f_write);
1680 ssiWriteString(d,(char *)dd);
1681 break;
1682 case INT_CMD: fputs("1 ",d->f_write);
1683 ssiWriteInt(d,(int)(long)dd);
1684 break;
1685 case BIGINT_CMD:fputs("4 ",d->f_write);
1686 ssiWriteBigInt(d,(number)dd);
1687 break;
1688 case NUMBER_CMD:
1689 if (d->r!=currRing)
1690 {
1691 fputs("15 ",d->f_write);
1693 if (d->level<=1) fputc('\n',d->f_write);
1694 }
1695 fputs("3 ",d->f_write);
1696 ssiWriteNumber(d,(number)dd);
1697 break;
1698 case RING_CMD:fputs("5 ",d->f_write);
1699 ssiWriteRing(d,(ring)dd);
1700 break;
1701 case BUCKET_CMD:
1702 {
1704 if (d->r!=sBucketGetRing(b))
1705 {
1706 fputs("15 ",d->f_write);
1708 if (d->level<=1) fputc('\n',d->f_write);
1709 }
1710 fputs("6 ",d->f_write);
1711 ssiWritePoly(d,tt,sBucketPeek(b));
1712 break;
1713 }
1714 case POLY_CMD:
1715 case VECTOR_CMD:
1716 if (d->r!=currRing)
1717 {
1718 fputs("15 ",d->f_write);
1720 if (d->level<=1) fputc('\n',d->f_write);
1721 }
1722 if(tt==POLY_CMD) fputs("6 ",d->f_write);
1723 else fputs("9 ",d->f_write);
1724 ssiWritePoly(d,tt,(poly)dd);
1725 break;
1726 case IDEAL_CMD:
1727 case MODUL_CMD:
1728 case MATRIX_CMD:
1729 case SMATRIX_CMD:
1730 if (d->r!=currRing)
1731 {
1732 fputs("15 ",d->f_write);
1734 if (d->level<=1) fputc('\n',d->f_write);
1735 }
1736 if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1737 else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1738 else if(tt==SMATRIX_CMD) fputs("22 ",d->f_write);
1739 else /* tt==MODUL_CMD*/
1740 {
1741 ideal M=(ideal)dd;
1742 fprintf(d->f_write,"10 %d ",(int)M->rank);
1743 }
1744 ssiWriteIdeal(d,tt,(ideal)dd);
1745 break;
1746 case COMMAND:
1747 fputs("11 ",d->f_write);
1749 break;
1750 case DEF_CMD: /* not evaluated stuff in quotes */
1751 fputs("12 ",d->f_write);
1752 ssiWriteString(d,data->Name());
1753 break;
1754 case PROC_CMD:
1755 fputs("13 ",d->f_write);
1756 ssiWriteProc(d,(procinfov)dd);
1757 break;
1758 case LIST_CMD:
1759 fputs("14 ",d->f_write);
1760 ssiWriteList(l,(lists)dd);
1761 break;
1762 case INTVEC_CMD:
1763 fputs("17 ",d->f_write);
1764 ssiWriteIntvec(d,(intvec *)dd);
1765 break;
1766 case INTMAT_CMD:
1767 fputs("18 ",d->f_write);
1768 ssiWriteIntmat(d,(intvec *)dd);
1769 break;
1770 case BIGINTMAT_CMD:
1771 fputs("19 ",d->f_write);
1773 break;
1774 default:
1775 if (tt>MAX_TOK)
1776 {
1777 blackbox *b=getBlackboxStuff(tt);
1778 fputs("20 ",d->f_write);
1779 b->blackbox_serialize(b,dd,l);
1780 }
1781 else
1782 {
1783 Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1784 d->level=0;
1785 return TRUE;
1786 }
1787 break;
1788 }
1789 if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1790 data=data->next;
1791 }
1792 d->level--;
1793 return FALSE;
1794}
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:17
CanonicalForm b
Definition: cfModGcd.cc:4103
Matrices of numbers.
Definition: bigintmat.h:51
Definition: intvec.h:23
Definition: attrib.h:21
attr next
Definition: attrib.h:26
Definition: lists.h:24
@ BUCKET_CMD
Definition: grammar.cc:283
ip_command * command
Definition: ipid.h:23
while(1)
Definition: libparse.cc:1444
char level
Definition: s_buff.h:27
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition: sbuckets.cc:46
sBucket * sBucket_pt
Definition: sbuckets.h:16