开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
rdlog2.c
资源名称：mrtg-2.13.2.zip　[点击查看]
上传用户：shbosideng
上传日期：2013-05-04
资源大小：1555k
文件大小：25k
源码类别：

SNMP编程

开发平台：

C/C++

rdlog2.c：源码内容
  1. /****************************************************************/
  2. /*                                                              */
  3. /* rdlog2.c (see readme.html for program explanation            */
  4. /*                                                              */
  5. /* author : Philippe Simonet, sip00@vg.swissptt.ch              */
  6. /*                                                              */
  7. /* change log :                                                 */
  8. /*                                                              */
  9. /* v. 1.00 : initial update (SIP) (02.12.97                     */
  10. /*                                                              */
  11. /*                                                              */
  12. /*                                                              */
  15. /************************************************************************/
  16. #include <stdio.h>
  17. #include <string.h>
  18. #include <stdlib.h>
  19. #include <malloc.h>
  20. #include <time.h>
  21. #include "gd.h"
  22. #include "gdfonts.h"
  24. #define FALSE 0
  25. #define TRUE 1
  27. #define TEXT 1
  28. #define RECT 2
  29. #define POLY 3
  30. #define COLOR 4
  31. #define COLORDEF 5
  32. #define LINK 6
  33. #define COMPOUND 7
  34. #define ENDCOMPOUND 8
  35. #define GIFAREA 9
  36. #define URL 10
  37. #define IN 11
  38. #define OUT 12
  39. #define INOUT 13
  40. #define UNKNOWN 99
  43. #ifndef max
  44.  #define max(a,b) ((a)>(b))?(a):(b)
  45. #endif
  47. #ifndef min
  48.  #define min(a,b) ((a)<(b))?(a):(b)
  49. #endif
  52. int colorratetable[256];
  54. int colortable[256] = {
  55. 0x000000, /* 0  BLACK */
  56. 0xff0000, /* 1  BLUE */
  57. 0x00ff00, /* 2  GREEN*/
  58. 0xffff00, /* 3  CYAN */
  59. 0x0000ff, /* 4  RED */
  60. 0xff00ff, /* 5  MAGENTA */
  61. 0x00ffff, /* 6  YELLOW */
  62. 0xffffff, /* 7  WHITE */
  63. 0x900000, /* 8  Blue4 */
  64. 0xb00000, /* 9  Blue3 */
  65. 0xd00000, /* 10 Blue2 */
  66. 0xffce87, /* 11 LtBlue */
  67. 0x009000, /* 12 Green4 */
  68. 0x00b000, /* 13 Green3 */
  69. 0x00d000, /* 14 Green2 */
  70. 0x909000, /* 15 Cyan4 */
  71. 0xb0b000, /* 16 Cyan3 */
  72. 0xd0d000, /* 17 Cyan2 */
  73. 0x000090, /* 18 Red4 */
  74. 0x0000b0, /* 19 Red3 */
  75. 0x0000d0, /* 20 Red2 */
  76. 0x900090, /* 21 Magenta4 */
  77. 0xb000b0, /* 22 Magenta3 */
  78. 0xd000d0, /* 23 Magenta2 */
  79. 0x003080, /* 24 Brown4 */
  80. 0x0040a0, /* 25 Brown3 */
  81. 0x0060c0, /* 26 Brown2 */
  82. 0x8080ff, /* 27 Pink4 */
  83. 0xa0a0ff, /* 28 Pink3 */
  84. 0xc0c0ff, /* 29 Pink2 */
  85. 0xe0e0ff, /* 30 Pink */
  86. 0x00d7ff /* 31 gold */
  87. };
  89. /************************************************************************/
  90. /* each of these entry contain the description of a graphical object    */
  91. struct sentry {
  92. int type; /* text, line, link, poly */
  93. int depth; /* order in which it appears */
  94. char * str; /* log file name, url, text */
  95. int maxrate; /* max xfer rate */
  96. int rate; /* max xfer rate */
  97. int orientation; /* text orientation, ... */
  98. int color; /* color */
  99. int fillcolor; /* color */
  100. int colorindex; /* color index */
  101. int npoints; /* fig size */
  102. int * coords; /* coordinates list */
  103. struct sentry * next; /* next entry */
  104. }; 
  106. int xsize, ysize, rounds, xoffset, yoffset;
  107. struct sentry * pfirstentry, *pcurrententry, *pareaentry;
  109. /************************************************************************/
  110. /* analyze command-line options */
  111. static int optind = 0;  /* Global argv index.  */
  112. static char *scan = NULL;   /* Private scan pointer. */
  113. static int scale = 15;
  115. int getopt1( int argc, char *argv[], char *optstring, char ** optarg )
  116. {
  117.     int  c; /* return value */
  118.     char  *place;
  119.     char     *index();
  121.     *optarg = NULL;
  123. /* check argument validity */
  124.     if (scan == NULL || *scan == '') {
  125.         if (optind == 0) optind++;
  126.         if (optind >= argc) return EOF;
  127.         place = argv[optind];
  128.         if (place[0] != '-' || place[1] == '') return EOF;
  129.         optind++;
  130.         if (place[1] == '-' && place[2] == '') return EOF;
  131.         scan = place+1;
  132.     }
  134.     c = *scan++; /* get option character */
  135.     place = strchr(optstring, c);
  136.     if (place == NULL || c == ':') return '?';
  139. /* set optarg if needed */
  140.     if (*++place == ':') {
  141.         if (*scan != '') {
  142.          *optarg = scan; scan = NULL;
  143.         } else {
  144.          *optarg = argv[optind], optind++;
  145.         }
  146.     }
  147.     return c;
  148. }
  150. /************************************************************************/
  151. /* computes a traffic in % by reading 'rounds' lines in a MRTG log file */
  152. /* currently, it takes the maximum of the In or OUT traffic.            */
  153. void read_entry ( struct sentry * pentry) {
  155. FILE * logf;
  156. int i, j=0, k=0;
  158. logf = fopen ( pentry->str, "r" );
  159. if ( pentry->maxrate == 0 ) {
  160. fprintf ( stderr, "Max rate for %s is null.n", pentry->str );
  161. return;
  162. }
  164. if ( logf != NULL ) {
  165. fscanf(logf, "%*d %d %d", &j, &k); /* get first line */
  167. for ( i = 0; i < rounds; i ++ ) { /* computes mean */
  168. fscanf(logf, "%*d %d %d %*d %*d", &j, &k); /* get line */
  169. /*printf(" - [%d %d]n", j, k);*/
  170. switch (pentry->orientation) {
  171. case IN:
  172. pentry->rate += j;
  173. break;
  174. case OUT:
  175. pentry->rate += k;
  176. break;
  177. default:
  178. if ( j > k ) pentry->rate += j;
  179. else pentry->rate += k;
  180. break;
  181. }
  182. }
  183. /* computes the rate 0-9 */
  184. pentry->rate = pentry->rate / rounds; 
  185. /*printf ( "%s : %u, %u.n", pentry->str, (pentry->maxrate*100)/pentry->maxrate, (pentry->rate*10)/pentry->maxrate );*/
  186. pentry->rate  = (pentry->rate * 10) / pentry->maxrate;
  187. if ( pentry->rate > 9 ) pentry->rate = 9;
  188. if ( pentry->rate < 0 ) pentry->rate = 0;
  189. fclose ( logf );
  190. } else {
  191. fprintf ( stderr, "Cannot open file %s.n", pentry->str );
  192. };
  193. }
  195. /************************************************************************/
  196. /* in case of trouble ...                                               */
  197. void print_error ( void )
  198. { 
  199. fprintf ( stderr, "Read mrtg configuration files and convert them in gif format.n" );
  200. fprintf ( stderr, "Use :n" );
  201. fprintf ( stderr, "  rdlog -i cfile -o gfile [-m mapfile] -r roundsn" );
  202. fprintf ( stderr, "   ifile : input fig file name,n" );
  203. fprintf ( stderr, "   gfile : output gif file (will be overwritten),n" );
  204. fprintf ( stderr, "   mapfile : output map file (optional, will be overwritten),n" );
  205. fprintf ( stderr, "   rounds : number of 5 min intervals to take.n" );
  206. }
  208. /************************************************************************/
  209. /* free an 'entry' variable                                             */
  210. void free_entry (struct sentry * pentry) {
  211. if ( pentry!= NULL ) {
  212. if ( pentry->str != NULL ) free(pentry->str); pentry->str = NULL;
  213. if ( pentry->coords != NULL ) free(pentry->coords); pentry->coords = NULL;
  214. free(pentry);
  215. }
  216. }
  219. /************************************************************************/
  220. /* print an entry for debug purpose                                     */
  221. void print_entry (struct sentry * pentry) {
  223. printf ( "Entry : " );
  224. if ( pentry->str != NULL ) printf ( "str '%s' ", pentry->str );
  225. printf ( ".n type %i, maxrate %i, orientation %i, npoints %i, color %i, depth %i.n",
  226. pentry->type,pentry->maxrate,pentry->orientation,pentry->npoints,pentry->color,pentry->depth );
  227. }
  229. /************************************************************************/
  230. int new_entry( void ) {
  232. struct sentry * pentry;
  234. if ( ( pentry = malloc ( sizeof (struct sentry) )) == NULL ) {
  235. fprintf ( stderr, "Error : memory allocation failure.n" );
  236. return ( FALSE );
  237. }
  239. if ( pfirstentry == NULL ) {
  240. pfirstentry = pentry;
  241. } else {
  242. pcurrententry->next = pentry;
  243. }
  245. pentry->type = UNKNOWN;
  246. pentry->str = NULL;
  247. pentry->maxrate = 0;
  248. pentry->rate = 0;
  249. pentry->orientation = 0;
  250. pentry->color = 0;
  251. pentry->fillcolor = 0;
  252. pentry->depth = 0;
  253. pentry->colorindex = 0;
  254. pentry->npoints = 0;
  255. pentry->coords = NULL;
  256. pentry->next = NULL;
  258. pcurrententry = pentry;
  260. return ( TRUE );
  261. }
  264. /************************************************************************/
  265. #define r(color) ((color&0x0000ff)>>0)
  266. #define g(color) ((color&0x00ff00)>>8)
  267. #define b(color) ((color&0xff0000)>>16)
  268. #define rgb(color) ((color&0x0000ff)>>0),((color&0x00ff00)>>8),((color&0xff0000)>>16)
  270. /************************************************************************/
  271. /* build a color or find the nearest color in the color table           */ 
  272. int find_color ( gdImagePtr graph, int color ) {
  273. int i_col;
  275. if ( (i_col = gdImageColorExact(graph,r(color), g(color), b(color))) == -1 ) {
  276. if ( (i_col = gdImageColorAllocate(graph,r(color), g(color), b(color))) == -1 ) {
  277. i_col = gdImageColorClosest(graph,r(color), g(color), b(color));
  278. }
  279. }
  280. return (i_col);
  281. }
  284. /************************************************************************/
  285. /* draw the gif file, based on the tentry desciption                    */
  286. void draw_gif ( FILE * gif )
  287. {
  288. #define c_blank 245,245,245 /* base colors */
  289. #define c_light 194,194,194
  290. #define c_dark 100,100,100
  291. #define c_black 0,0,0
  292. #define c_white 255,255,0
  294.     gdImagePtr graph;
  295. int i_light,i_dark,i_blank, i_black, i_white;
  296. int bkcolor;
  298.     graph = gdImageCreate(xsize, ysize);
  300.     /* the first color allocated will be the background color. */
  301. bkcolor = colortable[pareaentry->fillcolor];
  302.     i_blank = gdImageColorAllocate(graph,rgb(bkcolor));
  303.     i_light = gdImageColorAllocate(graph,c_light);
  304.     i_dark = gdImageColorAllocate(graph,c_dark);
  306.     gdImageInterlace(graph, 1); 
  308.     i_black = gdImageColorAllocate(graph,c_black);
  309.     i_white = gdImageColorAllocate(graph,c_white);
  311.     /* draw the image border */
  312.     gdImageLine(graph,0,0,xsize-1,0,i_light);
  313.     gdImageLine(graph,1,1,xsize-2,1,i_light);
  314.     gdImageLine(graph,0,0,0,ysize-1,i_light);
  315.     gdImageLine(graph,1,1,1,ysize-2,i_light);
  316.     gdImageLine(graph,xsize-1,0,xsize-1,ysize-1,i_dark);
  317.     gdImageLine(graph,0,ysize-1,xsize-1,ysize-1,i_dark);
  318.     gdImageLine(graph,xsize-2,1,xsize-2,ysize-2,i_dark);
  319.     gdImageLine(graph,1,ysize-2,xsize-2,ysize-2,i_dark);
  321. { /* date the graph */
  322. struct tm *newtime;
  323. time_t aclock;
  324. time( &aclock ); /* Get time in seconds */
  325. newtime = localtime( &aclock ); /* Convert time to struct */
  326. /* tm form */
  328. gdImageString(graph, gdFontSmall,3,3,asctime( newtime ),i_dark);
  329. };
  332. while ( 1 ) {
  333. int i_col, i_col2, depth;
  334. struct sentry * pentry;
  336. /* find smallest depth */
  337. pentry = pfirstentry;
  338. depth = -1;
  339. while ( pentry != NULL ) {
  340. if (pentry->depth > depth) {
  341. depth = pentry->depth;
  342. pcurrententry = pentry;
  343. }
  344. pentry = pentry->next;
  345. }
  346. if ( depth == -1 ) break;
  347. pcurrententry->depth = -1;
  349. /* draw this fig */
  350. switch ( pcurrententry->type) {
  351. case RECT:
  352. i_col = find_color(graph, colortable[pcurrententry->color]);
  355. if ( pcurrententry->fillcolor != -1 ) {
  357. i_col2 = find_color(graph, colortable[pcurrententry->fillcolor]);
  359. gdImageFilledRectangle(graph,
  360. pcurrententry->coords[0],
  361. pcurrententry->coords[1],
  362. pcurrententry->coords[2],
  363. pcurrententry->coords[3],i_col2);
  364. }
  366. gdImageRectangle(graph,
  367. pcurrententry->coords[0],
  368. pcurrententry->coords[1],
  369. pcurrententry->coords[2],
  370. pcurrententry->coords[3],i_col);
  371. break;
  372. case TEXT:
  373. i_col = find_color(graph, colortable[pcurrententry->color]);
  374. if (pcurrententry->orientation == 0) {
  375. gdImageString(graph, gdFontSmall,
  376. pcurrententry->coords[0],
  377. pcurrententry->coords[1],
  378. pcurrententry->str,
  379. i_col );
  380. } else {
  381. gdImageStringUp(graph, gdFontSmall,
  382. pcurrententry->coords[0],
  383. pcurrententry->coords[1],
  384. pcurrententry->str,
  385. i_col );
  386. }
  387. break;
  388. case POLY:
  389. case LINK:
  390. {
  391. int x = pcurrententry->coords[0];
  392. int y = pcurrententry->coords[1];
  393. int x2, y2, j, k;
  394. gdImagePtr brush_2pix;
  396. if (pcurrententry->type == POLY) {
  397. i_col = find_color(graph, colortable[pcurrententry->color]);
  398. } else {
  399. brush_2pix = gdImageCreate(2,2);
  400. gdImageColorAllocate(
  401. brush_2pix,
  402. r(colortable[colorratetable[pcurrententry->rate]]),
  403. g(colortable[colorratetable[pcurrententry->rate]]),
  404. b(colortable[colorratetable[pcurrententry->rate]]) );
  405.     gdImageSetBrush(graph, brush_2pix);
  406. i_col = gdBrushed;
  407. }
  409. k = 2;
  410. for ( j = 1; j < pcurrententry->npoints; j ++ ) {
  411. x2 = pcurrententry->coords[k++];
  412. y2 = pcurrententry->coords[k++];
  413. gdImageLine(graph, x, y, x2, y2,i_col);
  414. x = x2; y = y2;
  415. };
  417. if (pcurrententry->type == LINK) {
  418.     gdImageDestroy(brush_2pix);
  419. };
  421. }
  423. break;
  424. default:
  425. break;
  426. }
  427. pcurrententry = pcurrententry->next;
  428. }
  430.     gdImageGif(graph, gif);    
  432.     gdImageDestroy(graph);
  433. }
  436. struct sfigrec {
  437. int type;
  438. char text[500];
  439. int colorindex;
  440. int depth;
  441. int color;
  442. int fillcolor;
  443. int angle;
  444. int coords[500];
  445. int npoints;
  446. }; 
  449. /************************************************************************/
  450. int getfig ( FILE * config, struct sfigrec * fig ) 
  451. {
  452. char buf[1000], str[1000], *s;
  453. int i, n, type, color, colorindex, depth, pen_style, font, flags, x, y;
  454. int style, thickness, pen_color, fill_color, fill_style, join_style, cap_style, radius, fa, ba, npts;
  455. float tx_size, angle, style_val;
  457. fig->type = UNKNOWN;
  459. if ( fgets (buf, 1000, config ) == NULL ) {
  460. return ( TRUE );
  461. }
  463. switch ( buf[0] ) {
  464. case '0': /* color ref */
  465. n = sscanf(buf, "%*d %d #%06x", &colorindex, &color );
  466. /*printf ( "colordef : %d, %d.n", colorindex, color );*/
  467. fig->type = COLORDEF;
  468. fig->color = ((color & 0xff0000)>>16) | (color & 0x00ff00) | ((color & 0x0000ff)<<16);
  469. fig->colorindex = colorindex;
  470. break;
  471. case '2': /* polyline */
  472. n = sscanf(buf, "%*d%d%d%d%d%d%d%d%d%f%d%d%d%d%d%d",
  473.    &type, &style, &thickness, &pen_color, &fill_color,
  474.    &depth, &pen_style, &fill_style, &style_val,
  475.    &join_style, &cap_style, &radius, &fa, &ba, &npts);
  476. /*puts ( buf );*/
  477. /*printf ("type %d, style %d, thickness %d, pen_color %d, fill_color %d, depth %d, pen_style %d, fill_style %d, style_val %f, join_style %d, cap_style %d, radius %d, fa %d, ba %d, npts %d ",
  478.    type, style, thickness, pen_color, fill_color,
  479.    depth, pen_style, fill_style, style_val,
  480.    join_style, cap_style, radius, fa, ba, npts);*/
  481. fig->depth = depth;
  482. fig->color = pen_color;
  483. fig->npoints = npts;
  484. for ( i = 0; i < npts; i ++ ) {
  485. fscanf(config, "%d%d", &x, &y);
  486. fig->coords[i*2] = x; fig->coords[i*2+1] = y;
  487. /*printf ( "[%d %d] ", x, y );*/
  488. }
  489. fig->type = POLY;
  490. if ( type == 2 ) { /* rectangle */
  491. fig->type = RECT;
  492. if ( fill_style == -1 ) {
  493. fig->fillcolor = -1;
  494. } else {
  495. fig->fillcolor = fill_color;
  496. }
  497. x = min(fig->coords[0],fig->coords[4]);
  498. y = min(fig->coords[1],fig->coords[5]);
  499. fig->coords[2] = max(fig->coords[0],fig->coords[4]);
  500. fig->coords[3] = max(fig->coords[1],fig->coords[5]);
  501. fig->coords[0] = x;
  502. fig->coords[1] = y;
  503. fig->npoints = 2;
  504. }
  505. /*printf ( ".n" );*/
  506. break;
  507. case '4': /* text */
  508. n = sscanf(buf, "%*d%d%d%d%d%d%f%f%d%*f%*f%d%d %[^n]",
  509. &type, &color, &depth, &pen_style, &font, &tx_size, &angle, &flags, &x, &y, str);
  510. s = strstr ( str, "\001" );
  511. if ( s != NULL ) s[0] = 0;
  512. /*printf ( "text : type %d, color %d, depth %d, pen_style %d, font %d, ty_size %f, angle %f, flags %d, x %d, y %d, s [%s].n",
  513. type, color, depth, pen_style, font, tx_size, angle, flags, x, y, str );*/
  514. fig->type = TEXT;
  515. strcpy (fig->text, str);
  516. fig->depth = depth;
  517. fig->color = color;
  518. if ( angle < 1) {
  519. fig->angle = 0;
  520. fig->coords[0] = x;
  521. fig->coords[1] = y-150;
  522. } else {
  523. fig->angle = 1;
  524. fig->coords[0] = x-150;
  525. fig->coords[1] = y;
  526. }
  527. fig->npoints = 1;
  528. break;
  529. case '6': /* compound */
  530. fig->type = COMPOUND;
  531. /*printf ( "compound.n" );*/
  532. break;
  533. case '-': /* compound end */
  534. fig->type = ENDCOMPOUND;
  535. /*printf ( "end of compound.n" );*/
  536. break;
  537. default:
  538. break;
  539. }
  541. return ( FALSE );
  543. }
  546. /************************************************************************/
  547. void main ( int argc, char * argv[] )
  548. {
  549. FILE *config = NULL, *gif = NULL, *map = NULL;
  550. char  *sconfig = NULL, *sgif = NULL, *smap = NULL;
  551. char  *optarg;
  552. int i; 
  554. /* globals */
  555. xsize = 100, ysize = 100;
  556. rounds = 6;
  558. do {
  559. /***************************************************************/
  560. /* 0 : read program arguments */
  561. while ( ( i = getopt1( argc, argv, "o:i:r:m:", &optarg ) ) != EOF ) {
  562. switch ( i ) {
  563. case 'i':
  564. sconfig = optarg;
  565. break;
  566. case 'o':
  567. sgif = optarg;
  568. break;
  569. case 'm':
  570. smap = optarg;
  571. break;
  572. case 'r':
  573. rounds = atoi (optarg);
  574. if ( rounds < 1 ) {
  575. print_error();
  576. exit (0);
  577. };
  578. break;
  579. case '?':
  580. print_error();
  581. exit (0);
  582. break;
  583. default:
  584. break;
  585. }
  586. }
  589. if ( sconfig == NULL || sgif == NULL ) {
  590. print_error();
  591. break;
  592. }
  595. /***************************************************************/
  596. /* 1 : OPEN FILES */
  597. config = fopen ( sconfig, "r" );
  598. if ( config == NULL ) {
  599. fprintf ( stderr, "Error opening %s.n", sconfig );
  600. break;
  601. }
  603. gif = fopen ( sgif, "wb" );
  604. if ( gif == NULL ) {
  605. fprintf ( stderr, "Error opening %s.n", sgif );
  606. fclose ( config );
  607. break;
  608. }
  610. if ( smap != NULL ) {
  611. map = fopen ( smap, "w" );
  612. if ( map == NULL ) {
  613. fprintf ( stderr, "Error opening %s.n", sgif );
  614. fclose ( config );
  615. fclose ( gif );
  616. break;
  617. }
  618. fprintf ( map, "  <map name="map1">n" );
  619. }
  622. /***************************************************************/
  623. /* 2 : SCAN CONFIG FILE */
  624. pcurrententry = NULL; pfirstentry = NULL; pareaentry = NULL;
  625. for ( i = 0; i < 256; i++ ) {
  626. colorratetable[i] = 0;
  627. }
  628. for ( i = 32; i < 256; i++ ) {
  629. colortable[i] = 0;
  630. }
  632. while ( TRUE ) {
  633. struct sfigrec figrec;
  635. /********************************************/
  636. /* get one fig record */
  637. if ( getfig ( config, &figrec ) == TRUE ) break;
  639. switch (figrec.type) {
  640. case COLORDEF:
  641. if ( figrec.colorindex < 256 ) colortable[figrec.colorindex] = figrec.color;
  642. /*printf ( "color table[%i] : %i.n", figrec.colorindex, colortable[figrec.colorindex] );*/
  643. break;
  644. case TEXT:
  645. if ( new_entry() == FALSE ) break;
  646. pcurrententry->type = UNKNOWN;
  647. pcurrententry->color = figrec.color;
  648. pcurrententry->depth = figrec.depth;
  650. if ( strncmp("color:", figrec.text, 6 ) == 0 ) { /* special 'color:' text */
  651. i = atoi ( figrec.text+6 );
  652. if ( i < 256 ) colorratetable[i] = figrec.color;
  653. /*printf ( "color rate[%i] : %i.n", i, colorratetable[i] );*/
  654. break;
  655. }
  657. if ( (pcurrententry->str = malloc ( strlen(figrec.text) + 1 )) == NULL ) {
  658. fprintf ( stderr, "Error : memory allocation failure.n" );
  659. break;
  660. }
  661. if ( (pcurrententry->coords = (int *)malloc(figrec.npoints * (sizeof (int)) * 2 )) == NULL ) {
  662. fprintf ( stderr, "Error : memory allocation failure.n" );
  663. break;
  664. }
  665. pcurrententry->type = TEXT;
  666. pcurrententry->npoints = figrec.npoints;
  667. pcurrententry->orientation = figrec.angle;
  668. strcpy (pcurrententry->str,figrec.text);
  669. memcpy (pcurrententry->coords,figrec.coords,figrec.npoints * (sizeof (int)) * 2);
  670. break;
  671. case POLY:
  672. case RECT:
  673. if ( new_entry() == FALSE ) break;
  674. pcurrententry->type = UNKNOWN;
  675. pcurrententry->depth = figrec.depth;
  676. pcurrententry->color = figrec.color;
  677. pcurrententry->fillcolor = figrec.fillcolor;
  678. if ( (pcurrententry->coords = (int *)malloc(figrec.npoints * (sizeof (int)) * 2 )) == NULL ) {
  679. fprintf ( stderr, "Error : memory allocation failure.n" );
  680. continue;
  681. }
  682. pcurrententry->type = figrec.type;
  683. pcurrententry->npoints = figrec.npoints;
  684. memcpy (pcurrententry->coords,figrec.coords,figrec.npoints * (sizeof (int)) * 2);
  685. break;
  686. case COMPOUND: /* compound must be links ... */
  687. if ( new_entry() == FALSE ) break;
  688. do {
  689. if ( getfig ( config, &figrec ) == TRUE ) break;
  690. if ( figrec.type == ENDCOMPOUND ) break;
  691. if ( figrec.type == TEXT ) {
  692. /*printf (" txt %s.n", figrec.text );*/
  693. if ( strncmp("gifarea", figrec.text, 7 ) == 0 ) {
  694. pcurrententry->type = GIFAREA;
  695. pareaentry = pcurrententry;
  696. /*printf ( " gifarea : [%i / %i] ", pcurrententry->coords[0], pcurrententry->coords[1]);
  697. printf ( " [%i / %i].n", pcurrententry->coords[2], pcurrententry->coords[3]);*/
  698. } else if ( strncmp("url:", figrec.text, 4 ) == 0 ) {
  699. if ( (pcurrententry->str = malloc ( strlen(figrec.text) + 1 )) == NULL ) {
  700. fprintf ( stderr, "Error : memory allocation failure.n" );
  701. break;
  702. }
  703. pcurrententry->type = URL;
  704. strcpy (pcurrententry->str,figrec.text+4);
  705. /*printf (" url %s.n", pcurrententry->str );*/
  706. } else if ( strncmp("log:", figrec.text, 4 ) == 0 ) {
  707. char * s = figrec.text + 4;
  708. if ( s[0] == '>' ) {
  709. pcurrententry->orientation = OUT;
  710. s++;
  711. } else if ( s[0] == '<' ) {
  712. pcurrententry->orientation = IN;
  713. s++;
  714. } else {
  715. pcurrententry->orientation = INOUT;
  716. }
  717. if ( (pcurrententry->str = malloc ( strlen(s) + 1 )) == NULL ) {
  718. fprintf ( stderr, "Error : memory allocation failure.n" );
  719. break;
  720. }
  721. pcurrententry->type = LINK;
  722. strcpy (pcurrententry->str,s);
  723. /*printf (" str %s.n", pcurrententry->str );*/
  724. } else if ( strncmp("speed:", figrec.text, 6 ) == 0 ) {
  725. pcurrententry->maxrate = atoi ( figrec.text+6 );
  726. /*printf (" max rate : %i.n", pcurrententry->maxrate );*/
  727. }
  728. }
  729. if ( (figrec.type == POLY) || (figrec.type == RECT) ) {
  730. pcurrententry->color = figrec.color; /* default color */
  731. pcurrententry->depth = figrec.depth;
  732. pcurrententry->fillcolor = figrec.fillcolor; 
  733. if ( (pcurrententry->coords = (int *)malloc(figrec.npoints * (sizeof (int)) * 2 )) == NULL ) {
  734. fprintf ( stderr, "Error : memory allocation failure.n" );
  735. break;
  736. }
  737. pcurrententry->npoints = figrec.npoints;
  738. memcpy (pcurrententry->coords,figrec.coords,figrec.npoints * (sizeof (int)) * 2);
  739. }
  740. } while ( 1 );
  741. if ( pcurrententry->type==LINK && pcurrententry->coords != NULL ) {
  742. read_entry ( pcurrententry );
  743. /*printf (" link : log : %s.log, max rate : %i.n", pcurrententry->str, pcurrententry->maxrate );*/
  744. }
  745. break;
  746. case ENDCOMPOUND:
  747. case UNKNOWN:
  748. default:
  749. break;
  750. }
  752. }
  754. /***************************************************************/
  755. /* checks */
  756. if ( pareaentry == NULL ) {
  757. fprintf ( stderr, "Error : no gif area specified.n");
  758. break;
  759. }
  760. xsize = (pareaentry->coords[2] - pareaentry->coords[0]);
  761. ysize = (pareaentry->coords[3] - pareaentry->coords[1]);
  762. xoffset = pareaentry->coords[0]; yoffset = pareaentry->coords[1];
  763. /*printf ( "size : %i %i.n", xsize, ysize );
  764. printf ( "offset : %i %i.n", xoffset, yoffset );*/
  766. /***************************************************************/
  767. /*  do translations                                            */
  768. pcurrententry = pfirstentry;
  769. while ( pcurrententry != NULL ) {
  770. for (i = 0; i < pcurrententry->npoints; i ++) {
  771. pcurrententry->coords[i*2] -= xoffset;
  772. pcurrententry->coords[i*2+1] -= yoffset;
  773. pcurrententry->coords[i*2] /= scale;
  774. pcurrententry->coords[i*2+1] /= scale;
  775. }
  776. if ( smap != NULL ) {
  777. if ( pcurrententry->type==URL && pcurrententry->coords != NULL ) {
  778. fprintf ( map, "   <area href=%s alt="%s" shape=rect coords="%i,%i,%i,%i">n", 
  779. pcurrententry->str,pcurrententry->str,
  780. pcurrententry->coords[0],pcurrententry->coords[1],
  781. pcurrententry->coords[2],pcurrententry->coords[3] );
  782. }
  783. }
  784. pcurrententry = pcurrententry->next;
  785. }
  786. xsize /= scale; ysize /=scale;
  788. /***************************************************************/
  789. /* 3 : draw gif file                                           */
  790. draw_gif ( gif );
  792. /***************************************************************/
  793. /* 4 : clean-up all    */
  794. {
  795. struct sentry * pentry;
  796. pcurrententry = pfirstentry;
  797. do {
  798. pentry = pcurrententry->next;
  799. free_entry(pcurrententry);
  800. pcurrententry = pentry;
  801. } while ( pentry != NULL );
  802. }
  804. fclose ( gif );
  805. fclose ( config );
  807. if ( smap != NULL ) {
  808. /*<area href=lk311.html alt="lk311.html" shape=rect coords="240,12,270,24">*/
  809. fprintf ( map, "  </map>n" );
  810. fclose ( map );
  811. }
  813. break;
  815. } while ( TRUE );
  817. }